import { SourcePosition } from "@re-do/node";
import { Func, IsAnyOrUnknown } from "@re-do/utils";
import { AssertionConfig } from "../assert.js";
import { TypeAssertions } from "../type/context.js";
export declare type ChainableValueAssertion<ArgsType extends [value: any, ...rest: any[]], Config extends AssertionConfig, Chained = ArgsType[0], IsReturn extends boolean = false, ImmediateAssertions = ValueAssertion<Chained, Config> & (IsReturn extends true ? NextAssertions<Config> : {})> = (<Args extends ArgsType | [] = []>(...args: Args) => Args extends [] ? ImmediateAssertions : NextAssertions<Config>) & ImmediateAssertions;
export declare type ChainableAssertionOptions = {
    isReturn?: boolean;
    allowRegex?: boolean;
};
export declare const chainableAssertion: (position: SourcePosition, valueThunk: () => unknown, config: AssertionConfig, { isReturn, allowRegex }?: ChainableAssertionOptions) => (expected: unknown) => TypeAssertions | ({
    returns: ChainableValueAssertion<[value: unknown], Required<import("../assert.js").AssertionOptions>, unknown, true, any & {
        args: (...args: unknown[]) => any;
    } & {
        is: (value: unknown) => {};
        snap: ((value?: string | undefined) => undefined) & {
            toFile: () => undefined;
        };
        equals: (value: unknown) => {};
    }>;
    throws: ChainableValueAssertion<[message: string | RegExp], Required<import("../assert.js").AssertionOptions>, string, false, {
        is: (value: string) => {};
        snap: ((value?: string | undefined) => undefined) & {
            toFile: () => undefined;
        };
        equals: (value: string) => {};
    }>;
} & {
    args: (...args: unknown[]) => any;
} & {
    is: (value: unknown) => {};
    snap: ((value?: string | undefined) => undefined) & {
        toFile: () => undefined;
    };
    equals: (value: unknown) => {};
}) | undefined;
export declare type ComparableValueAssertion<T, Config extends AssertionConfig> = {
    is: (value: T) => NextAssertions<Config>;
    snap: ((value?: string) => undefined) & {
        toFile: () => undefined;
    };
    equals: (value: T) => NextAssertions<Config>;
} & (Config["allowTypeAssertions"] extends true ? {
    typedValue: (expected: unknown) => undefined;
} : {});
export declare type CallableFunctionAssertion<Return, Config extends AssertionConfig> = {
    returns: ChainableValueAssertion<[value: Return], Config, Return, true>;
    throws: ChainableValueAssertion<[message: string | RegExp], Config, string>;
} & (Config["allowTypeAssertions"] extends true ? {
    throwsAndHasTypeError: (message: string | RegExp) => undefined;
} : {});
export declare type FunctionalValueAssertion<Args extends any[], Return, Config extends AssertionConfig> = FunctionAssertionWithArgsIfNeeded<Args, CallableFunctionAssertion<Return, Config>>;
export declare type FunctionAssertionWithArgsIfNeeded<Args extends any[], AssertionsOnceCallable> = ([] extends Args ? AssertionsOnceCallable : {}) & (Args extends [] ? {} : {
    args: (...args: Args) => AssertionsOnceCallable;
});
export declare type NextAssertions<Config extends AssertionConfig> = Config["allowTypeAssertions"] extends true ? TypeAssertions : {};
export declare type ValueAssertion<T, Config extends AssertionConfig> = IsAnyOrUnknown<T> extends true ? FunctionalValueAssertion<T[], T, Config> & ComparableValueAssertion<T, Config> : T extends Func<infer Args, infer Return> ? FunctionalValueAssertion<Args, Return, Config> : ComparableValueAssertion<T, Config>;
export declare const getNextAssertions: (position: SourcePosition, config: AssertionConfig) => TypeAssertions | undefined;
export declare const valueAssertions: <T, Config extends Required<import("../assert.js").AssertionOptions>>(position: SourcePosition, value: T, config: Config) => ValueAssertion<T, Config>;