Type checking with omit params

I'm trying to define some type based on a base Type.

• 'Simple' Type has a name and type property
• 'Base' Type has a property name that cannot be 'text' or 'radio'
• I create a 'Radio' and a 'Texto' type

But when I create an object with type: 'radio', it does not make mandatory the 'radio' or 'freq' properties...

I don't know why...

Can someone can highlight the issue please ?

type Simple = {
    name: string
    type: string
}

type Base = Exclude<Simple, {type: 'text'|'radio'}>

type Radio = Base & {
    type: 'radio',
    radio: string,
    freq: string
};

type Texto = Base & {
    type: 'text'
    label: string
}

type Field = Radio | Texto | Base

/**
 * I expect to see an error thrown with 'freq' and 'radio' is missing here...
 */
const myRadio:Field = {
    type: 'radio',
    name:'snig'
}

There's no specific type in TypeScript that corresponds to all string values except "text" and "radio", so you can't give Base a specific type that distinguishes it from Texto or Radio. That would require so-called negated types as implemented in microsoft/TypeScript#29317 but never released. So you can't say string & not ("text" | "radio"). The Exclude utility type can only filter union types but since neither string nor Simple are union types, it has no effect.

In the absence of specific types that work the way you want, you could try a generic type and use it to constrain the input values. So instead of const myRadio: Field = {⋯}, you'd need to write something like const myRadio: Field<"radio"> = {⋯}. Or, if you don't want to manually write that type argument, you could write a utility function to infer the type argument, and instead write const myRadio= field({⋯}) and myRadio will have its type inferred as Field<"radio">. It could look like this:

type KnownField = Radio | Texto;

type Field<T extends string> =
    T extends KnownField['type'] ?
    Extract<KnownField, { type: T }> :
    Simple;

const field = <T extends (string & {}) | KnownField['type']>(
    t: { type: T } & Field<T>
): Field<T> => t;

Here Field<T> is implemented as a conditional type that discriminates KnownField using T as a discriminant if it applies (using the Extract utility type, or else falling back to Simple. And field() is a helper function that gives you the inference you want.

Let's try it:

const myRadio = field({
    type: 'radio',
    name: 'snig'
}); // error!
//   Type '{ type: "radio"; name: string; }' is missing the following properties from type
//  '{ type: "radio"; radio: string; freq: string; }': radio, freq

That's the error you wanted. And if you inspect myRadio, its type is Radio. The following code compiles with no errors:

const t = field({ type: "text", name: "abc", label: "abc" });
// const t: Texto
const r = field({ type: "radio", name: "abc", radio: "abc", freq: "abc" });
// const r: Radio
const s = field({ type: "random", name: "abc" });
// const s: Simple

Looks good.

Playground link to code