Lookahead/lookbehind every in word boundary

First time here, was always lurking around an able to find answers, but not this time.

I'm doing a REGEX with lookbehind and lookahead to show me where do I start having only letters and only numbers.

Some examples:

| is the pointer

AAA111 -> AAA|111

222BBB -> 222|BBB

AAA111AAA -> No pointer, cause there is letters after the number sequence

AAA111AAA111 -> No pointer, cause in the second, there is letters behind the number

I tried a lot to no avail, everytime I reach a problem of 2 matches when there should be none, or no matches when there should be one.

If it was possible to make something like "If anything behind the pointer is a letter, negative"
with lookbehind or likewise with lookahead, I think I could do it. But I couldn't find an example or way to do it.

EDIT: I'm using this regex in Java, inside a ReplaceAll() to add a space to a full sentence. Real example:

'NEW CITY - TCM34759' = 'NEW CITY - TCM 35779'

'TOWER CBM25432' = 'TOWER CBM 25432'

This seems difficult to handle using a single regex pattern with lookarounds. I suggest a two step approach. First, find matches using the following regex pattern:

^(?:[A-Za-z]+[0-9]+|[0-9]+[A-Za-z]+)$

Then, use this pattern to flag the position which bisects letters from numbers or vice-versa:

(?<=[A-Za-z])(?=[0-9])|(?<=[0-9])(?=[A-Za-z])

Java regex engine allows limited variable length lookbehinds, with them you can check the start of the word from the replacement position:

(?=\d+\b)(?<=\b[A-Z]{1,100})|(?=[A-Z]+\b)(?<=\b\d{1,100})

demo

This is not the kind of problem to use assertions.
If you want to use assertions as an exercise feel free, but it does slow down the search.

The easiest way is to match the separation inside an alternation, where the block is surrounded by a word boundary.

These 4 groups are just linearly gathered to formulate a straightforward substitution.

Find (?i)\b(?:([a-z]+)(\d+)|(\d+)([a-z]+))\b
Replace $1$3 $2$4

https://regex101.com/r/2X9pyr/1

 (?i)
 \b 
 (?:
    ( [a-z]+ )         # (1)
    ( \d+ )            # (2)
  | 
    ( \d+ )            # (3)
    ( [a-z]+ )         # (4)
 )
 \b