I did some work on this, and...

Disclaimer: this isn't a formal proof, and some things may be left out (like saying we're using integers), but it should be clear what is happening.

First thing, it helps to realize that this isn't really a number, its a list of digits.

Second thing, I changed the order around to make things easier - instead of the order:

number of 1s, number of 2s, etc., number of 9s, number of 0s,

I used:

number of 9s, number of 8s, etc., number of 0s,

which means

`2100010006`

`1234567890` (position)

becomes

`0001000126`

`9876543210` (position).

So, for base *b*, let *n* equal *b* - 1 (for convenience).
Then, the digits are

*d*_{n} , *d*_{n-1} , *d*_{n-2} , ... , *d*_{1} , *d*_{0}

This means that *d*_{i}, where *i* is an integer between 0 and *n*, inclusive, is the count of the number of *i*s in the full number.
For example, in decimal and using 0001000126, the digits are *d*_{9} to *d*_{0} , and *d*_{0} = 6, *d*_{1} = 2, *d*_{3} = 1, etc.

From that, it is possible to determine some rules.

As m_turner stated, the sum of the digits equals the base. This means

*d*_{n} + *d*_{n-1} + ... + *d*_{1} + *d*_{0} = *b* = *n* + 1

Note that for all digits, *i* must occur *d*_{i} times (that is why this is so special in the first place). This yields two things.

The first is:

*d*_{n}(*n*) + *d*_{n-1}(*n*-1) + ... + *d*_{1}(1) + *d*_{1}(0) = *n* + 1

which reduces to

*d*_{n}(*n*) + *d*_{n-1}(*n*-1) + ... + *d*_{1}(1) = *n* + 1 ,

and the second is that *d*_{i} *i* must be less than *b* = *n* + 1, for all *i* :

*d*_{i} < trunc( (*n* + 1) / *i* ) ,

where trunc is the round-down function (so, for example, trunc(2), trunc(2.4), trunc(2.5), and trunc(2.9) are all equal to 2).
Using this second fact, *n* occurs *d*_{n} times, so

*d*_{n} < trunc( (*n* + 1) / *n* ) = a value between 1 and 2, for bases 3 and higher,

which reduces to

*d*_{n} < 1 ,

which means

*d*_{n} = 0

which reduces the search space from *n*^{n} to *n*^{n - 1}.

Note: since that equals 0, then there must be at least one 0:

*d*_{0} ≥ 1, or *d*_{0} is greater than or equal to 1 .

That is all I've determined so far, you may want to try finding the range other *d*_{i} values can be, using the trunc inequality.