import Maybe from './Maybe';
export declare type Arg<F> = F extends (arg: infer A) => unknown ? A : never;
export declare type Return<F> = F extends (...args: Array<unknown>) => infer R ? R : never;
export declare type Optional<O extends object> = {
    [K in keyof O]?: O[K];
};
export declare type Compute<A> = A extends infer O ? {
    [K in keyof O]: O[K];
} : never;
export declare type IsNever<A, T, F> = [A] extends [never] ? T : F;
export declare type WhenNever<A, T> = [A, T] extends [T, A] ? A : IsNever<A, T, A>;
export declare type WhenUnknown<A, T> = [A, T] extends [T, A] ? A : (unknown extends A ? T : A);
export declare type Cata<O extends {
    [K in keyof O]: (...args: Array<unknown>) => unknown;
} & {
    _?: never;
}> = O extends {
    [K in keyof O]: (...args: Array<unknown>) => infer R;
} ? Compute<O & {
    _?(): never;
}> | Compute<Optional<O> & {
    _(): R;
}> : never;
export declare function identity<T>(value: T): T;
export declare function inst<T>(Constructor: new () => T): T;
export declare function cons<A extends Array<unknown>, T>(Constructor: new (...args: A) => A extends [] ? never : T): (...args: A) => T;
export declare function isString(value: unknown): value is string;
export declare function isNumber(value: unknown): value is number;
export declare const isFloat: typeof isNumber;
export declare function isInt(value: unknown): value is number;
export declare function isBoolean(value: unknown): value is boolean;
export declare function isArray(input: unknown): input is Array<unknown>;
export declare function isObject(input: unknown): input is {
    [key: string]: unknown;
};
export declare function toInt(input: string): Maybe<number>;
export interface Order {
    isLT(): boolean;
    isEQ(): boolean;
    isGT(): boolean;
    fold<R>(onLT: () => R, onEQ: () => R, onGT: () => R): R;
    cata<R>(pattern: Order.Pattern<R>): R;
}
export declare namespace Order {
    type Pattern<R> = Cata<{
        LT(): R;
        EQ(): R;
        GT(): R;
    }>;
    const LT: Order;
    const EQ: Order;
    const GT: Order;
}
export interface Comparable<T> {
    compareTo(another: T): Order;
}
export declare const isComparable: <T>(something: unknown) => something is Comparable<T>;