import { isPresentArray } from "@starbeam/core-utils";
type FixedArray<T, N extends number, SoFar extends unknown[] = [
]> = SoFar["length"] extends N ? SoFar : FixedArray<T, N, [
    T,
    ...SoFar
]>;
type ReadonlyFixedArray<T, N extends number, SoFar extends readonly unknown[] = [
]> = SoFar["length"] extends N ? SoFar : ReadonlyFixedArray<T, N, readonly [
    T,
    ...SoFar
]>;
declare function isPresent<T>(value: T | null | undefined): value is Exclude<T, null | undefined>;
declare function exhaustive(_value: never, type?: string): never;
declare function isEqual<T>(value: T): (other: unknown) => other is T;
declare function isNotEqual<T>(value: T): <U>(other: U) => other is Exclude<U, T>;
declare function isObject(value: unknown): value is object;
declare function isWeakKey(value: unknown): value is Record<string, unknown>;
interface HasLength<L extends number> {
    <T>(value: T[]): value is FixedArray<T, L>;
    <T>(value: readonly T[]): value is ReadonlyFixedArray<T, L>;
}
declare function hasLength<L extends number>(length: L): HasLength<L>;
declare const hasItems: typeof isPresentArray;
declare function isNullable<In, Out extends In>(verifier: (value: In) => value is Out): (value: In | null) => value is Out | null;
declare function isOneOf<In, Out extends In>(...verifiers: ((value: In) => value is Out)[]): (value: In) => value is Out;
declare function hasType<K extends keyof TypeOfTypes>(type: K): (value: any) => value is TypeOfTypes[K];
interface TypeOfTypes {
    string: string;
    number: number;
    bigint: bigint;
    boolean: boolean;
    symbol: symbol;
    undefined: undefined;
    null: null;
    object: object;
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    function: (...args: any[]) => unknown;
}
type TypeOf = keyof TypeOfTypes;
declare class VerificationError<T = unknown> extends Error {
    readonly expectation: Expectation<T>;
    constructor(message: string, expectation: Expectation<T>);
}
type VerifyFn = <Input extends Value, Value, Output extends Input>(value: Value, check: (input: Input) => input is Output, error?: Expectation<Value>) => asserts value is Output & Value;
declare function verify<Input extends Value, Value, Output extends Input>(value: Value, check: (input: Input) => input is Output, error?: Expectation<Value>): asserts value is Output & Value;
declare namespace verify {
    var noop: typeof verify | {
        <Input, Output extends Input, Value extends Output>(value: Value, check: (input: Input) => input is Output, error?: Expectation<Value> | undefined): void;
        <Input_1, Value_1 extends Input_1, Output_1 extends Input_1>(value: Value_1, check: (input: Input_1) => input is Output_1, error?: Expectation<Value_1> | undefined): asserts value is Output_1 & Value_1;
    };
}
declare function verified<T, U extends T>(value: T, check: (input: T) => input is U, error?: Expectation<T>): U;
declare namespace verified {
    var noop: <T, U extends T>(value: T, _check: (input: T) => input is U, _error?: Expectation<T> | undefined) => U;
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
declare class Expectation<In = any> {
    #private;
    static create<In>(description?: string): Expectation<In>;
    static merge<In>(associated: Expectation<In> | undefined, specified: Expectation<In> | undefined): Expectation<In> | undefined;
    private constructor();
    as(description: string): Expectation<In>;
    update<NewIn>(updater: Updater<In, NewIn>): Expectation<NewIn>;
    toBe(kind: string): Expectation<In>;
    toHave(items: string): Expectation<In>;
    butGot<NewIn extends In>(kind: string | ((value: NewIn) => string)): Expectation<NewIn>;
    when(situation: string): Expectation<In>;
    message(input: In): string;
}
type Relationship = "to be" | "to have" | "to be one of";
type To = [
    relationship: Relationship,
    kind: string
];
declare function expected(description?: string): Expectation;
declare namespace expected {
    var as: typeof expected;
    var toBe: (kind: string) => Expectation<any>;
    var toHave: (items: string) => Expectation<any>;
    var when: (situation: string) => Expectation<any>;
    var butGot: <In>(kind: string | ((input: In) => string)) => Expectation<In>;
    var associate: <Check extends (input: In) => any, In>(check: Check, expectation: Expectation<In>) => Check extends infer C ? C : never;
    var updated: <In, NewIn = In>(check: (input: In) => boolean, updater: Updater<In, NewIn>) => Expectation<NewIn>;
}
interface Updater<In, NewIn = In> {
    description?: (description: string | undefined) => string | undefined;
    to?: (to: To | undefined) => string | To | undefined;
    actual?: (actual: ((input: In) => string | undefined) | undefined) => ((input: NewIn) => string | undefined) | undefined;
    when?: (when: string | undefined) => string | undefined;
}
declare const verifiedDev: typeof verified;
declare const verify$0: VerifyFn;
declare const verified$0: typeof verifiedDev["noop"];
export { exhaustive, hasItems, hasLength, isEqual, isNotEqual, isNullable, isObject, isPresent, isWeakKey, isOneOf, TypeOf, hasType, Expectation, expected, VerificationError, verify$0 as verify, verified$0 as verified };
//# sourceMappingURL=index.d.ts.map