import { HKT } from "@tsplus/stdlib/prelude/HKT";
type KindFromObj<F extends HKT, __> = HKT.Kind<F, HKT.Infer<F, "R", __>, HKT.Infer<F, "E", __>, HKT.Infer<F, "A", __>>;
export interface MatchFn<F extends HKT, N extends string> {
    <X extends {
        [tag in N]: string;
    }, K extends {
        [k in X[N]]: (_: Extract<X, {
            [tag in N]: k;
        }>, __: Extract<X, {
            [tag in N]: k;
        }>) => HKT.Kind<F, any, any, any>;
    }>(matcher: K): (_: X) => KindFromObj<F, {
        [k in keyof K]: ReturnType<K[k]>;
    }[keyof K]>;
    <X extends {
        [tag in N]: string;
    }, K extends Partial<{
        [k in X[N]]: (_: Extract<X, {
            [tag in N]: k;
        }>, __: Extract<X, {
            [tag in N]: k;
        }>) => HKT.Kind<F, any, any, any>;
    }>, Ret extends HKT.Kind<F, any, any, any>>(matcher: K, def: (_: Exclude<X, {
        [tag in N]: keyof K;
    }>, __: Exclude<X, {
        [tag in N]: keyof K;
    }>) => Ret): (_: X) => KindFromObj<F, {
        [k in keyof K]: K[k] extends (...args: any) => any ? ReturnType<K[k]> : never;
    }[keyof K] | Ret>;
}
export interface MatchInFn<F extends HKT, N extends string> {
    <X extends {
        [tag in N]: string;
    }>(): {
        <K extends {
            [k in X[N]]: (_: Extract<X, {
                [tag in N]: k;
            }>, __: Extract<X, {
                [tag in N]: k;
            }>) => HKT.Kind<F, any, any, any>;
        }>(matcher: K): (_: X) => KindFromObj<F, {
            [k in keyof K]: ReturnType<K[k]>;
        }[keyof K]>;
        <K extends Partial<{
            [k in X[N]]: (_: Extract<X, {
                [tag in N]: k;
            }>, __: Extract<X, {
                [tag in N]: k;
            }>) => HKT.Kind<F, any, any, any>;
        }>, Ret extends HKT.Kind<F, any, any, any>>(matcher: K, def: (_: Exclude<X, {
            [tag in N]: keyof K;
        }>, __: Exclude<X, {
            [tag in N]: keyof K;
        }>) => Ret): (_: X) => KindFromObj<F, {
            [k in keyof K]: K[k] extends (...args: any) => any ? ReturnType<K[k]> : never;
        }[keyof K] | Ret>;
    };
}
export interface MatchMorphFn<F extends HKT, N extends string, X extends {
    [tag in N]: string;
}> {
    <K extends {
        [k in X[N]]: (_: Extract<X, {
            [tag in N]: k;
        }>, __: Extract<X, {
            [tag in N]: k;
        }>) => HKT.Kind<F, any, any, any>;
    }>(matcher: K): (_: X) => KindFromObj<F, {
        [k in keyof K]: ReturnType<K[k]>;
    }[keyof K]>;
    <X extends {
        [tag in N]: string;
    }, K extends Partial<{
        [k in X[N]]: (_: Extract<X, {
            [tag in N]: k;
        }>, __: Extract<X, {
            [tag in N]: k;
        }>) => HKT.Kind<F, any, any, any>;
    }>, Ret extends HKT.Kind<F, any, any, any>>(matcher: K, def: (_: Exclude<X, {
        [tag in N]: keyof K;
    }>, __: Exclude<X, {
        [tag in N]: keyof K;
    }>) => Ret): (_: X) => KindFromObj<F, {
        [k in keyof K]: K[k] extends (...args: any) => any ? ReturnType<K[k]> : never;
    }[keyof K] | Ret>;
}
/**
 * @tsplus static DSL matchers
 * @tsplus location "@tsplus/stdlib/prelude/DSL/matchers"
 */
export declare function matchers<F extends HKT>(): {
    match: <N extends string>(tag: N) => MatchFn<F, N>;
    matchTag: MatchFn<F, "_tag">;
    matchIn: <N_1 extends string>(tag: N_1) => MatchInFn<F, N_1>;
    matchTagIn: MatchInFn<F, "_tag">;
    matchMorph: <N_2 extends string, X extends { [tag in N_2]: string; }>(MorphADT: {
        tag: N_2;
        _A: X;
    }) => MatchMorphFn<F, N_2, X>;
};
export {};
//# sourceMappingURL=matchers.d.ts.map