import { InstanceClass } from '@shedevro/core';
declare namespace Defined {
    namespace Asserts {
        type One = {
            defined<T>(value: T, message?: string): asserts value is NonNullable<T>;
        };
        type Array = {
            defined<T>(value: T[], message?: string): asserts value is NonNullable<T[]>;
        };
        type ArrayNullable = {
            defined<T>(value: T[] | unknown, message?: string): asserts value is NonNullable<T[]> | null;
        };
        type Not = {
            defined(value: unknown, message?: string): asserts value is null | undefined;
        };
    }
    namespace ValueIs {
        type One = {
            defined<T>(value: T): value is NonNullable<T>;
        };
        type Array = {
            defined<T>(value: T[]): value is NonNullable<T[]>;
        };
        type ArrayNullable = {
            defined<T>(value: T[] | unknown): value is NonNullable<T[]> | null;
        };
        type Not = {
            defined(value: unknown): value is null | undefined;
        };
    }
}
declare namespace Equal {
    namespace Asserts {
        type One = {
            equal<TExpect extends string | number | boolean>(value: unknown, expect: TExpect, message?: string): asserts value is TExpect;
        };
        type Not = {
            equal<TValue, TExpect extends string | number | boolean>(value: TValue, expect: TExpect, message?: string): asserts value is Exclude<TValue, TExpect>;
        };
    }
    namespace ValueIs {
        type One = {
            equal<TExpect extends string | number | boolean>(value: unknown, expect: TExpect): value is TExpect;
        };
        type Not = {
            equal<TValue, TExpect extends string | number | boolean>(value: TValue, expect: TExpect): value is Exclude<TValue, TExpect>;
        };
    }
}
declare namespace Throws {
    namespace Asserts {
        type One = {
            throws(expression: unknown, expectedErrorClass?: InstanceClass, message?: string): void;
        };
    }
    namespace ValueIs {
        type One = {
            throws(expression: unknown, expectedErrorClass?: InstanceClass): boolean;
        };
    }
}
export declare namespace OtherFunctions {
    namespace Asserts {
        type One = Defined.Asserts.One & Equal.Asserts.One & Throws.Asserts.One;
        type OneNullable = Equal.Asserts.One;
        type Array = Defined.Asserts.Array;
        type ArrayNullable = Defined.Asserts.ArrayNullable;
        type Not = Defined.Asserts.Not & Equal.Asserts.Not & Throws.Asserts.One;
    }
    namespace ValueIs {
        type One = Defined.ValueIs.One & Equal.ValueIs.One & Throws.ValueIs.One;
        type OneNullable = Equal.ValueIs.One;
        type Array = Defined.ValueIs.Array;
        type ArrayNullable = Defined.ValueIs.ArrayNullable;
        type Not = Defined.ValueIs.Not & Equal.ValueIs.Not & Throws.ValueIs.One;
    }
}
export {};