type checking that value is not one of several values

In typescript you can use an enum as a type in order to ensure that a variable has a value that is within the enum. For example:

type children = "Andy" | "Bob"

export const func = (name: children) : void => {
...
};

However, I wish for functionality that ensures the value of a variable is NOT within an enum (or any other kind of collection). I know this can be achieved with simple if statements/for loops but I'm hoping that when the variable is not one of certain values, something like a type error will be thrown. Is there something like the opposite of an enum that I can use to check a variable name is NOT one of several values? In the above example, I would want it so that the value of name is ensured not to be Andy or Bob.

TypeScript lacks negated types (of the sort implemented in microsoft/TypeScript#29317 but never merged into the language), so there's no specific type corresponding to "all strings that are not Children". If there were you could write type NotChildren = string & not Children and then just have (name: NotChildren) => {}. Instead, we'll need to simulate them by using generics.

The approach I'll take here is to observe that a generic type T that's been constrained to string should be rejected if and only if there's no overlap whatsoever between T and Children. That is, the intersection of T and Children should be the empty/impossible never type. So let's make func generic in T and give name the conditional type (T & Children) extends never ? T : never, which evaluates to T if T & Children has no overlap, and never otherwise:

type Children = "Andy" | "Bob";
export const func = <T extends string>(
  name: (T & Children) extends never ? T : never
): void => { };

The basic usage looks like this:

func("Andy"); // error;
// const func: <"Andy">(name: never) => void

func("Bob"); // error
// const func: <"Bob">(name: never) => void

func("Charie"); // okay; 
// const func: <"Charie">(name: "Charie") => void

The first two calls fail because when T is inferred to be the literal types "Andy" or "Bob", then T & Children is possible, so (T & Children) extends never is false, and so (T & Children) extends never ? T : never is never, and so the arguments are rejected.

The second call succeeds because when T is inferred to be literal type "Charlie", then T & Children is impossible, so (T & Children) extends never is true, and so (T & Children) extends never ? T : never is T, and so the argument is accepted.

So that looks good, so far.

Now for some more complicated situations:

func(Math.random() < 0.5 ? "Andy" : "Charlie"); // error
// const func: <"Andy" | "Charlie">(name: never) => void

That fails because the argument is either "Andy" or "Charlie", and since there is some overlap between Children and that type (namely "Andy"), then it is rejected.

Also rejected is an arbitrary string:

function foo(x: string) {
  func(x); // error, maybe it's "Andy" or "Bob"
  // const func: <string>(name: never) => void
}

because there's overlap between string and Children (namely, Children). Note that the compiler and a human being might have a different view of what constitutes an "arbitrary" string. If you use the + operator to concatenate strings, the compiler doesn't try to figure out what that might be, and just widens it to string. So this is rejected:

func("Char" + "lie"); // error 
// const func: <string>(name: never) => void

We know that's "Charlie", but the compiler doesn't, so it can't accept it.

On the other hand it accepts the following call:

function bar(x: `Char${string}`) {
  func(x); // okay, no way it can be "Andy" or "Bob"
  // const func: <`Char${string}`>(name: `Char${string}`) => void
}

The pattern template literal type (as implemented in ms/TS#40598) `Char${string}` means "any string starting with "Char"". The compiler understands that there is no overlap between such a type and Children, so it works.

Conversely the following fails:

function baz(x: `An${string}`) {
  func(x); // error
  // const func: <`An${string}`>(name: never) => void
}

because there is overlap between "strings that start with "An"" and Children, namely "Andy".

So essentially, when in doubt, the compiler rejects the call. That could make it somewhat difficult to use, since arbitrary string inputs are not accepted, but that's presumably what you want!

Playground link to code