import type { Erase, UnionToIntersection } from './util/types';
export interface Auto {
}
export interface Base<F, C = Auto> {
    readonly _F: F;
    readonly _C: C;
}
export interface BaseHKT<F, C = Auto> {
    readonly _HKT: unique symbol;
    readonly _URI: F;
    readonly _C: C;
}
export declare type MapURIS<F, C = Auto> = F extends [URI<infer U, infer CU>, ...infer Rest] ? [URI<U, CU & C>, ...MapURIS<Rest, C>] : [];
export declare type CompositionBase2<F extends URIS, G extends URIS, CF = Auto, CG = Auto> = Base<[
    ...MapURIS<F, CF>,
    ...MapURIS<G, CG>
]>;
export declare const HKT_URI = "HKT";
export declare type HKT_URI = typeof HKT_URI;
export interface HKT<URI, A> {
    readonly _URI: URI;
    readonly _A: A;
}
export declare const HKT2_URI = "HKT2";
export declare type HKT2_URI = typeof HKT2_URI;
export interface HKT2<URI, E, A> extends HKT<URI, A> {
    readonly _E: E;
}
export declare const HKT3_URI = "HKT3";
export declare type HKT3_URI = typeof HKT3_URI;
export interface HKT3<URI, R, E, A> extends HKT2<URI, E, A> {
    readonly _R: R;
}
export declare const HKT4_URI = "HKT4";
export declare type HKT4_URI = typeof HKT4_URI;
export interface HKT4<URI, S, R, E, A> extends HKT3<URI, R, E, A> {
    readonly _S: S;
}
export declare type UHKT<F> = [URI<'HKT', CustomType<'F', F>>];
export declare type UHKT2<F> = [URI<'HKT2', CustomType<'F', F>>];
export declare type UHKT3<F> = [URI<'HKT3', CustomType<'F', F>>];
export declare type UHKT4<F> = [URI<'HKT4', CustomType<'F', F>>];
/**
 * A type-level dictionary for HKTs: URI -> Concrete Type
 */
export interface URItoKind<FC, TC, N extends string, K, Q, W, X, I, S, R, E, A> {
    [HKT_URI]: HKT<AccessCustom<FC, 'F'>, A>;
    [HKT2_URI]: HKT2<AccessCustom<FC, 'F'>, E, A>;
    [HKT3_URI]: HKT3<AccessCustom<FC, 'F'>, R, E, A>;
    [HKT4_URI]: HKT4<AccessCustom<FC, 'F'>, S, R, E, A>;
}
/**
 * A type-level dictionary for indexed HKTs
 */
export interface URItoIndex<N extends string, K> {
    [HKT_URI]: K;
    [HKT2_URI]: K;
    [HKT3_URI]: K;
    [HKT4_URI]: K;
}
export declare type ConcreteURIS = keyof URItoKind<any, any, any, any, any, any, any, any, any, any, any, any>;
export declare type URIS = [URI<ConcreteURIS, any>, ...URI<ConcreteURIS, any>[]];
export interface URI<F extends ConcreteURIS, C = {}> {
    readonly _F: F;
    readonly _C: C;
}
export declare type AppendURI<F extends URIS, G extends URI<ConcreteURIS, any>> = F extends URIS ? [...F, G] : F;
export declare type PrependURI<G extends URI<ConcreteURIS, any>, F extends URIS> = F extends URIS ? [G, ...F] : F;
export declare type Rest<F extends [any, ...any[]]> = F extends [any, ...infer Rest] ? Rest : [];
export declare type Kind<F extends URIS, C, N extends string, K, Q, W, X, I, S, R, E, A> = F extends [any, ...infer Next] ? Next extends URIS ? URItoKind<F[0]['_C'], C, OrFix<'N', F[0]['_C'], OrFix<'N', C, N>>, OrFix<'K', F[0]['_C'], OrFix<'K', C, K>>, OrFix<'Q', F[0]['_C'], OrFix<'Q', C, Q>>, OrFix<'W', F[0]['_C'], OrFix<'W', C, W>>, OrFix<'X', F[0]['_C'], OrFix<'X', C, X>>, OrFix<'I', F[0]['_C'], OrFix<'I', C, I>>, OrFix<'S', F[0]['_C'], OrFix<'S', C, S>>, OrFix<'R', F[0]['_C'], OrFix<'R', C, R>>, OrFix<'E', F[0]['_C'], OrFix<'E', C, E>>, Kind<Next, C, N, K, Q, W, X, I, S, R, E, A>>[F[0]['_F']] : URItoKind<F[0]['_C'], C, OrFix<'N', F[0]['_C'], OrFix<'N', C, N>>, OrFix<'K', F[0]['_C'], OrFix<'K', C, K>>, OrFix<'Q', F[0]['_C'], OrFix<'Q', C, Q>>, OrFix<'W', F[0]['_C'], OrFix<'W', C, W>>, OrFix<'X', F[0]['_C'], OrFix<'X', C, X>>, OrFix<'I', F[0]['_C'], OrFix<'I', C, I>>, OrFix<'S', F[0]['_C'], OrFix<'S', C, S>>, OrFix<'R', F[0]['_C'], OrFix<'R', C, R>>, OrFix<'E', F[0]['_C'], OrFix<'E', C, E>>, A>[F[0]['_F']] : never;
export declare type Infer<F extends URIS, C, P extends Param | 'A' | 'C', K> = [K] extends [
    Kind<F, C, infer N, infer K, infer Q, infer W, infer X, infer I, infer S, infer R, infer E, infer A>
] ? P extends 'C' ? C : P extends 'N' ? N : P extends 'K' ? K : P extends 'Q' ? Q : P extends 'W' ? W : P extends 'X' ? X : P extends 'I' ? I : P extends 'S' ? S : P extends 'R' ? R : P extends 'E' ? E : P extends 'A' ? A : never : never;
export declare type URIOf<K extends Kind<any, any, any, any, any, any, any, any, any, any, any, any>> = K extends Kind<infer F, any, any, any, any, any, any, any, any, any, any, any> ? F : never;
export declare type IndexForBase<F extends ConcreteURIS, N extends string, K> = F extends keyof URItoIndex<any, any> ? URItoIndex<N, K>[F] : K;
export declare type IndexFor<F extends URIS, N extends string, K> = IndexForBase<{
    [K in keyof F]: F[K] extends ConcreteURIS ? F[K] : F[K] extends URI<infer U, any> ? U : never;
}[number], N, K>;
export declare type CompositionIndexForBase<F extends ConcreteURIS[], N extends string, K> = 1 extends F['length'] ? F[0] extends keyof URItoIndex<any, any> ? URItoIndex<N, K>[F[0]] : K : {
    [P in keyof F]: F[P] extends keyof URItoIndex<any, any> ? URItoIndex<N, K>[F[P]] : K;
};
export declare type CompositionIndexFor<F extends URIS, N extends string, K> = CompositionIndexForBase<{
    [K in keyof F]: F[K] extends ConcreteURIS ? F[K] : F[K] extends URI<infer U, any> ? U : never;
}, N, K>;
export interface CustomType<P extends string, V> {
    CustomType: {
        [p in P]: () => V;
    };
}
export declare type AccessCustom<C, P extends string, D = any> = C extends CustomType<P, infer V> ? V : D;
export declare type AccessCustomExtends<C, P extends string, D = any> = C extends CustomType<P, infer V> ? V extends D ? V : D : D;
export declare type Param = 'N' | 'K' | 'Q' | 'W' | 'I' | 'X' | 'S' | 'R' | 'E';
export interface Fix<P extends Param, F> {
    Fix: {
        [p in P]: {
            F: () => F;
        };
    };
}
export declare type OrFix<P extends Param, A, B> = A extends Fix<P, infer X> ? P extends 'N' ? X extends string ? X : B : X : B;
export declare type Unfix<C, P extends Param> = (Exclude<keyof C, 'Fix'> extends never ? unknown : {
    [K in Exclude<keyof C, 'Fix'>]: C[K];
}) & (keyof C & 'Fix' extends never ? unknown : {
    [K in keyof C & 'Fix']: {
        [KK in Exclude<keyof C[K], P>]: C[K][KK];
    };
});
export declare type CleanParam<C, P extends Param> = C extends (Auto | V<P, '_'> | V<P, '+'> | Fix<P, any>) & infer X ? X : C;
export declare type OrNever<K> = unknown extends K ? never : K;
export declare type Variance = '+' | '-' | '_';
export interface V<F extends Param, V extends Variance> {
    Variance: {
        [v in V]: () => F;
    };
}
/**
 * Composes types according to variance specified in C
 */
export declare type Mix<C, P extends Param, X extends [any, ...any[]]> = C extends V<P, '_'> ? X[0] : C extends V<P, '+'> ? X[number] : C extends V<P, '-'> ? X extends [any] ? X[0] : X extends [any, any] ? X[0] & X[1] : X extends [any, any, any] ? X[0] & X[1] & X[2] : X extends [any, any, any, any] ? X[0] & X[1] & X[2] & X[3] : X extends [any, any, any, any, any] ? X[0] & X[1] & X[2] & X[3] & X[4] : X extends [any, any, any, any, any, any] ? X[0] & X[1] & X[2] & X[3] & X[4] & X[5] : UnionToIntersection<{
    [k in keyof X]: OrNever<X[k]>;
}[keyof X]> : X[0];
/**
 * Composes a record of types to the base respecting variance from C
 */
export declare type MixStruct<C, P extends Param, X, Y> = C extends V<P, '_'> ? X : C extends V<P, '+'> ? Y[keyof Y] : C extends V<P, '-'> ? P extends 'N' ? string : UnionToIntersection<{
    [k in keyof Y]: OrNever<Y[k]>;
}[keyof Y]> : X;
/**
 * Used in subsequent definitions to either vary a paramter or keep it fixed to "Fixed"
 */
export declare type Intro<C, P extends Param, Fixed, Current> = C extends V<P, '_'> ? Fixed : C extends V<P, '+'> ? Current : C extends V<P, '-'> ? Current : Fixed;
/**
 * Initial type depending on variance of P in C (eg: initial Contravariant R = unknown, initial Covariant E = never)
 */
export declare type Initial<C, P extends Param> = C extends V<P, '-'> ? P extends 'N' ? string : unknown : C extends V<P, '+'> ? never : any;
export declare type Strip<C, P extends Param> = Erase<C, V<P, '_'> & V<P, '-'> & V<P, '+'>>;
export declare type Ignores = '_F' | '_G' | 'Commutative' | '_C' | '_CF' | '_CG';
/**
 * A helper for constructing typeclass instances
 */
export declare const instance: <T>(_: Omit<T, Ignores>) => T;
//# sourceMappingURL=HKT.d.ts.map