Better type error message for `<MatchTag>` with missing cases

import type { Accessor, JSX } from 'solid-js'

type Cases<IsPartial extends boolean, T> =
    boolean extends IsPartial
        ? { 'no `boolean` allowed, please use either `true` or `false`': never }
        : true extends IsPartial
            ? Partial<T>
            : Required<T>

type NotProvidedOrTyped<K extends string, V, Default> =
    | (V extends Default ? Partial<Record<K, never>> : never)
    | Required<Record<K, V>>

type Tag = string | number
type TagKeyDefault = "type"
type PartialDefault = false
declare function MatchTag<
    T extends { [k in TagKey]: Tag },
    TagKey extends string = TagKeyDefault,
    IsPartial extends boolean = PartialDefault,
>(
    props:
        & {
            on: T | null | undefined;
            case: Cases<IsPartial, { [Tag in T[TagKey]]: (v: Accessor<Extract<T, Record<TagKey, Tag>>>) => JSX.Element }>;
            fallback?: JSX.Element;
        }
        & NotProvidedOrTyped<"tag", TagKey, TagKeyDefault>
        & NotProvidedOrTyped<"partial", IsPartial, PartialDefault>
): JSX.Element;

type MyUnion =
  | {
        kind: "foo";
        foo: "foo-value";
    }
  | {
        kind: "bar";
        bar: "bar-value";
    };

declare const value: () => MyUnion

// normal case
<MatchTag
    on={value()}
    tag="kind"
    case={{
        foo: props => <>{props().foo}</>,
        bar: props => <>{props().bar}</>,
    }}
/>;

// edge cases
<MatchTag
    on={value()}
    tag="kind"
    case={{}}
    // much more clear error message:
    // Type '{}' is missing the following properties from
    // type 'Required<{
    //   foo: (v: Accessor<{ kind: "foo"; foo: "foo-value"; }>) => Element;
    //   bar: (v: Accessor<{ kind: "bar"; bar: "bar-value"; }>) => Element;
    // }>': foo, bar
/>;
<MatchTag<MyUnion, "kind">
    // properly handles "explicit generic argument without providing optional arguments" hazard (see https://github.com/microsoft/TypeScript/issues/58977)
    on={value()}
    // `tag` prop is not actually provided
    case={{
        foo: () => <></>,
        bar: () => <></>,
    }}
/>;
<MatchTag<MyUnion, "kind", true>
    // handles `partial` too!
    on={value()}
    tag="kind"
    case={{}}
    // `partial` prop is not actually provided
/>;
<MatchTag<MyUnion, "kind", boolean>
    on={value()}
    tag="kind"
    case={{}} // bans ambiguous `partial: boolean`
/>;

type MyUnionWithTypeTag =
  | {
        type: "foo";
        foo: "foo-value";
    }
  | {
        type: "bar";
        bar: "bar-value";
    };

declare const valueTypeTag: () => MyUnionWithTypeTag

// normal case
<MatchTag
    on={valueTypeTag()}
    case={{
        foo: props => <>{props().foo}</>,
        bar: props => <>{props().bar}</>,
    }}
/>;

// edge cases
<MatchTag
    on={valueTypeTag()}
    case={{}}
/>;