import { InferMatch, TagUnion, Pattern } from './match';
declare type Tags<ADT extends TagUnion> = ADT['tag'];
export declare type Member<ADT extends TagUnion, Tag extends Tags<ADT>> = InferMatch<'tag', ADT, Tag>;
export declare type UntaggedMember<ADT extends TagUnion, Tag extends Tags<ADT>> = Omit<Member<ADT, Tag>, 'tag'>;
declare type As<ADT extends TagUnion> = {
    [Tag in Tags<ADT>]: (args: UntaggedMember<ADT, Tag>) => Member<ADT, Tag>;
};
declare type Of<ADT extends TagUnion> = {
    [Tag in Tags<ADT>]: (args: UntaggedMember<ADT, Tag>) => ADT;
};
declare type Is<ADT extends TagUnion> = {
    [Tag in Tags<ADT>]: (arg: ADT) => arg is Member<ADT, Tag>;
};
declare type Match<ADT extends TagUnion> = <A>(pattern: Pattern<'tag', ADT, A>) => (adt: ADT) => A;
export declare type TaggedUnionUtils<ADT extends TagUnion> = {
    as: As<ADT>;
    of: Of<ADT>;
    is: Is<ADT>;
    match: Match<ADT>;
};
declare type TagTuple<U extends string, R extends string[] = []> = {
    [S in U]: Exclude<U, S> extends never ? [...R, S] : TagTuple<Exclude<U, S>, [...R, S]>;
}[U];
declare type Flatten<A> = {
    [K in keyof A]: A[K];
} & {};
export declare type TaggedUnion<A extends Record<string, {}>> = {
    [Tag in keyof A]: Flatten<{
        tag: Tag;
    } & A[Tag]>;
}[keyof A];
export declare const TaggedUnion: <ADT extends TagUnion>(tags: TagTuple<Tags<ADT>, []>) => TaggedUnionUtils<ADT>;
export {};