I think this might be an instance of the TypeScript design limitation reported in [microsoft/TypeScript#41164](https://github.com/microsoft/TypeScript/issues/41164).  As [mentioned there](https://github.com/microsoft/TypeScript/issues/41164#issuecomment-712418462),

> Certain circularities are allowed [...] but other circularities aren't, e.g.
>
>     type Identity<T> = T;
>     type T3 = Identity<T3>;
>
> Generic instantiation is *deferred*, so at the point TS analyzes [a] declaration, it can't tell if it's in the `Record` case (would be allowed) or the `Identity` case (would not be allowed). It's only later in the process that we could tell that this is actually OK, but if it wasn't OK, it's "too late" to go back and start complaining about it.

If that's the issue, then while the following should be "okay", it seems that the compiler cannot tell early enough to allow it:

    // type IQuery = string | ["AND" | "OR", ...Array<IQuery>] error

(I changed your definition slightly to allow the `const query1 = "Hello"` line).

---

Luckily, `Array<T>` has an alternative built-in syntax `T[]` which does not seem to be deferred in that manner:

    type IQuery = string | ["AND" | "OR", ...IQuery[]] // okay
    
And this works:

    const query1: IQuery = "Hello"
    const query2: IQuery = ["AND", "Hello", "World"]
    const query3: IQuery = ["OR", ["AND", "Hello", "World"], ["AND", "Hola", "Mundo"]]
    const query4: IQuery = ["AND", ["OR", ["AND"]]]; 

    const badQuery1: IQuery = 3; // error
    // Type 'number' is not assignable to type 'IQuery'
    const badQuery2: IQuery = ["AND", "Hello", 123]; // error
    // Type 'number' is not assignable to type 'IQuery'
    const badQuery3: IQuery = 
      ["OR", query1, query2, "then", query3, query4, "if", []]; // error
    // Type '[]' is not assignable to type 'IQuery'.

[Playground link to code](https://www.typescriptlang.org/play?#code/PTAEBcE8AcFNQJIEUCusBOlQF5QGdx0BLAOwHNQAfUAbQCIBBAOQBE6rQ6B5AJToBpQAOhEN06AIaQAPMjSYAfAF1QGdAHt0AKChxEqDFlwFi5DvWZsO3PoJFC5hmkpUhQ6gNZStWgMbqSAlAAR3lIAEYALn0wnE4ACVgAGyT1Oj8AoNDDACZox0w4i1YBBOTU0roAdU0kgBM6JQzA8BCwgGZ8g0Lcel5S4rZBOkSUtOGa9HrGwUHK+PUkiUqAWRQSOrSXZqywgBYu2N7GEtmbAZO2FyUAblA3cAALIjxQF-cvLHB1dVAffxaoAARhI6t0IodDHF2nc3GpNFo3AAVGDwADkJBQAFsgRg0W9XiR1K0JHg8EQyCQJECkvBvhBUaA0QVIGidq0QWCwnkYlDjpZ5uVxqBwjl2rd7mB4dpkYyMdjceh8e8iSSyRSqTS6b9dOiWWyAUFOeDOryerRzoJsphwlbucMnrASKVrZB2nbDHthkQAGYDFywqXiBGyvRo5zKwnE0Ck8mU6m0iA6uX6oRaIA)
    



I have an array of query elements, where each element can be a term or a subquery containing  starting with either "AND" or "OR", and followed by an array of legal query elements, terms or nested subqueries, and so on.

For example, these should all be legal input:

```js
const query1 = "Hello"
const query2 = ["AND", "Hello", "World"]
const query3 = ["OR", ["AND", "Hello", "World"], ["AND", "Hola", "Mundo"]]
```

[**Variadric Tuples**][1] in **TS 4.0** should allow you to type the first element of an array and another type for the rest:

```ts
type IQuery = ["AND" | "OR", ...Array<string>]
const query = ["AND", "Hello", "World"]  // valid
```

[**Recursive Types**][2] in **TS 3.7** should allow you to define an type that uses itself:

```ts
type IQueryOps = string | Array<IQueryOps>
const query: IQueryOps = ["Hello", "World", ["Hola", "Mundo"]]  // valid
```

But I can't seem to combine the two when the circular type is spread. In this case, each query begins with an operator, and is followed up by either a string or another valid query like this:

```ts
type IOperator = "AND" | "OR"
type IQuery = [IOperator, ...Array<string | IQuery>]
```

In this case, I get the error:

> Type alias 'IQuery' circularly references itself.(2456)

Is there anyway to type this, even with workarounds, or do I have to unwrap it to the desired level of depth I'd like to support from a types perspective?

### [Demo in TS Playground][3]

### Further Reading

* [Define a type for an array where the first element is more specific than the rest][4]
* [How to create a circularly referenced type in TypeScript?][5]

[1]: https://devblogs.microsoft.com/typescript/announcing-typescript-4-0-beta/#variadic-tuple-types
[2]: https://github.com/microsoft/TypeScript/pull/33050
[3]: https://www.typescriptlang.org/play?#code/FAFwngDgpgBAkgRQK5QE5gGoENUEssAmeAxjALwwDaARAIIByAItTAD4zUDyAStQDQwAdMNqpUWMAB4AziDwA7AOYA+ALrBiAe3myYARxTpseQiQBc8ZGkw58RXKQo0GzAdQASUADZfN-DgDqmqheBNTqoJCwiIZg3FDESKjSuABusBSyCopsMKLiUjHW8YnJaVDKGtq6BsUJSSnpFkXoJQ3l5FQe3r7+1EEhYQI07ppeWH0AskjyBH6qEZHQ8JzQ4iDBnXRMLOxcvEvRVuidlHCraFgbqALCgvkSMnK4SrktYGrAAPRfMAAqURgWC8+GkMAA5O9wTBiLhUIlxiEwDBUFAAGZoKDyYhQMG4EDSbxowQACgATAAWACsADYAJTAKo6ED6WIWLIvHLsd6nfb+Zw7NyeHx+NwDULhYbbVwcUbjKYzObhVRAA
[4]: https://stackoverflow.com/q/44402096/1366033
[5]: https://stackoverflow.com/q/36966444/1366033