enum FieldWithoutId {
    NOID1,
    NOID2,
    NOID3,
    NOID4,
    NOID5,
    NOID6,
    NOID7,
    NOID8,
    NOID9,
    NOID10,
    NOID11,
    NOID12,
    NOID13,
    NOID14,
    NOID15,
    NOID16,
    NOID17,
    NOID18,
    NOID19,
    NOID20,
    NOID21,
    NOID22,
    NOID23,
    NOID24,
    NOID25,
    NOID26, // commenting out this line makes everything work
}

enum FieldWithId {
    ID1,
    ID2
}

type WrapperWithId<T extends FieldWithId = FieldWithId> = {
    field: T;
    id: number;
};

type WrapperWithoutId<
    T extends FieldWithoutId = FieldWithoutId
> = {
    field: T;
};

type Field = FieldWithId | FieldWithoutId;

type Wrapper<T extends Field = Field> = T extends FieldWithoutId ? WrapperWithoutId<T>
: T extends FieldWithId ? WrapperWithId<T> : WrapperWithId | WrapperWithoutId;

const toWrapper = (field: Field, id?: number): Wrapper => {
    if (field === FieldWithId.ID1 || field === FieldWithId.ID2) {
        if (!id) {
            throw new Error();
        }
        return {
            field,
            id,
        };
    } else {
        const x: FieldWithoutId = field;
        // fails to compile. Is distribution of conditional type too large?
        return { field: x };
    }
}

// Using a "non-distributive" conditional type. Not sure if that's the correct description or what makes this non-distributive though. Wording taken from 
type NonDistributiveWrapper<T extends Field = Field> = [T] extends [FieldWithoutId] ? WrapperWithoutId<T>
: [T] extends [FieldWithId] ? WrapperWithId<T> : WrapperWithId | WrapperWithoutId;

const toNonDistributiveWrapper = (field: Field, id?: number): NonDistributiveWrapper => {
    if (field === FieldWithId.ID1 || field === FieldWithId.ID2) {
        if (!id) {
            throw new Error();
        }
        return {
            field,
            id,
        };
    } else {
        const x: FieldWithoutId = field;
        return { field: x }; // works. Why?
    }
}

// Want to be able to do this, which prevents making Wrapper a union type?
type Container<T extends Field = Field> = {
    wrapper: Wrapper<T>;
    value: T extends FieldWithoutId ? undefined : number;
}

function foo(container: Container<FieldWithId>) {
    return container.wrapper.id + container.value;
}

// If we try to make Wrapper a union type instead (which is reasonable), we can't do that:
export type Wrapper2 = WrapperWithId | WrapperWithoutId;

type ContainerNoParameterizedWrapper<T extends Field = Field> = {
    wrapper: Wrapper2;
    value: T extends FieldWithoutId ? undefined : number;
}

function foo2(container: ContainerNoParameterizedWrapper<FieldWithId>) {
    return container.wrapper.id + container.value; // fails to compile
}