import type { TT$ } from './types';
declare type IfChainedValue<D, V> = V | ((data?: D) => V);
declare type IfChainedCondition<D> = IfChainedValue<D, TT$<boolean>>;
declare type CallableValue<T> = {
    callable: () => T;
};
declare type Selector<D, T = any, E = any, N = any> = {
    if?: IfChainedCondition<D>;
    then: T | CallableValue<T>;
    else?: E | CallableValue<E>;
    next?: N;
};
declare type IfChainedSelector<D, T = any, E = any, N = any> = IfChainedValue<D, Selector<D, T, E, N>>;
declare type Ex<S extends Selector<any>, K> = K extends keyof S ? K extends 'then' ? S[K] extends CallableValue<any> ? ReturnType<S[K]['callable']> : S[K] : K extends 'else' ? S[K] extends CallableValue<any> ? ReturnType<S[K]['callable']> : S[K] : S[K] : never;
declare type ExtractS<S extends IfChainedSelector<any>, K extends keyof Selector<any>> = S extends (...args: any) => any ? Ex<ReturnType<S>, K> : S extends Selector<any> ? Ex<S, K> : never;
export declare type IfChainedNext<D, V = never, Done extends boolean = false> = {
    next: Done extends true ? never : <S extends IfChainedSelector<D>>(selector: S) => IfChainedNext<[
        ExtractS<S, 'next'>
    ] extends [never] ? D : ExtractS<S, 'next'>, V | ExtractS<S, 'then'> | ExtractS<S, 'else'>, Done extends true ? Done : S extends {
        else: any;
    } ? true : false>;
    value: V;
};
export declare type IfChained = <D>(data?: D) => {
    next: <S extends IfChainedSelector<D>>(selector: S) => IfChainedNext<D, ExtractS<S, 'then'> | ExtractS<S, 'else'>, S extends {
        else: any;
    } ? true : false>;
};
export declare const ifChained: IfChained;
export declare const ifThen: IfChained;
declare type Condition<T, E> = {
    if?: TT$<boolean>;
    then: T | CallableValue<T>;
    else?: E | CallableValue<E>;
};
export declare const ifthen: <C extends Condition<any, any>>(condition: C) => ExtractS<C, "then"> | ExtractS<C, "else">;
export {};