assert.d.ts

type Falsy = null | undefined | false | 0 | -0 | 0n | "";
type StringLike = string | String;
type Nullish = undefined | null;
type NonNullablePrimitive = boolean | number | bigint | string | symbol;
type Primitive = Nullish | NonNullablePrimitive;
type NonPrimitive = object | Function;
type Comparable = number | bigint | string | boolean | Date;
type AssertionErrorOptions = {
    message?: string;
    actual?: any;
    expected?: any;
    operator?: any;
    stackStartFn?: Function;
    diff?: any;
};
type TestResult<T> = {
    ok: true;
    value: T;
    block: Function;
    name: string;
} | {
    ok: false;
    error: Error;
    block: Function;
    name: string;
};
type ExpectedType = string | Function | Array<string | Function>;
type IncludesOptions = {
    keyOrValue: any;
    value?: any;
};
type Message = string | Error;
declare class AssertionError extends Error {
    actual?: unknown;
    expected?: unknown;
    operator?: string;
    code?: string;
    generatedMessage?: boolean;
    constructor(options?: AssertionErrorOptions);
}
declare function assert(value: unknown, message?: Message): asserts value;
declare namespace assert {
    var VERSION: string;
    var config: {
        alwaysStrict: boolean;
    };
    export { AssertionError };
    export { ok };
    export { equal };
    export { notEqual };
    export { strictEqual };
    export { notStrictEqual };
    export { deepEqual };
    export { notDeepEqual };
    export { deepEqual as deepStrictEqual };
    export { notDeepEqual as notDeepStrictEqual };
    export { throws };
    export { rejects };
    export { doesNotReject };
    export { fail };
    export { notOk };
    export { isTrue };
    export { isNotTrue };
    export { isFalse };
    export { isNotFalse };
    export { is };
    export { typeOf };
    export { notTypeOf };
    export { instanceOf };
    export { notInstanceOf };
    export { isNot };
    export { isNullish };
    export { isNullish as ifError };
    export { isNonNullable };
    export { isNull };
    export { isNotNull };
    export { isUndefined };
    export { isDefined };
    export { isString };
    export { isNotString };
    export { isNumber };
    export { isNotNumber };
    export { isBigInt };
    export { isNotBigInt };
    export { isBoolean };
    export { isNotBoolean };
    export { isSymbol };
    export { isNotSymbol };
    export { isFunction };
    export { isNotFunction };
    export { isObject };
    export { isNotObject };
    export { isPrimitive };
    export { isNotPrimitive };
    export { isNaN };
    export { isNotNaN };
    export { isInt };
    export { isNotInt };
    export { isFloat };
    export { isNotFloat };
    export { isEmpty };
    export { isNotEmpty };
    export { match };
    export { doesNotMatch };
    export { lt };
    export { lte };
    export { gt };
    export { gte };
    export { inRange };
    export { notInRange };
    export { stringContains };
    export { stringNotContains };
    export { stringStartsWith };
    export { stringNotStartsWith };
    export { stringEndsWith };
    export { stringNotEndsWith };
    export { includes };
    export { doesNotInclude };
    export { oneOf };
    export { notOneOf };
    export { operator };
    export { testSync };
    export { testSync as test };
    export { testSync as it };
    export { testAsync };
    export { testCheck };
    export { TestSuite };
}
declare const ok: (value: unknown, message?: Message) => asserts value;
declare const equal: (actual: unknown, expected: unknown, message?: Message) => void;
declare const notEqual: (actual: unknown, expected: unknown, message?: Message) => void;
declare const strictEqual: (actual: unknown, expected: unknown, message?: Message) => void;
declare const notStrictEqual: (actual: unknown, expected: unknown, message?: Message) => void;
declare function deepEqual(actual: unknown, expected: unknown, message?: Message): void;
declare function notDeepEqual(actual: unknown, expected: unknown, message?: Message): void;
declare function throws(block: Function, Error_opt?: unknown, message?: Message): Error | undefined;
declare function rejects(block: Function | Promise<unknown>, Error_opt?: unknown, message?: Message): Promise<unknown>;
declare function doesNotReject(block: Function, Error_opt?: unknown, message?: Message): Promise<unknown>;
declare function fail(message?: Message): void;
declare function fail(actual?: unknown, expected?: unknown, message?: Message, operator?: unknown): void;
declare const notOk: (value: unknown, message?: Message) => asserts value is Falsy;
declare const isTrue: (value: unknown, message?: Message) => asserts value is true;
declare const isNotTrue: <T>(value: T, message?: Message) => asserts value is Exclude<T, true>;
declare const isFalse: (value: unknown, message?: Message) => asserts value is false;
declare const isNotFalse: <T>(value: T, message?: Message) => asserts value is Exclude<T, false>;
declare function is(value: unknown, expectedType: ExpectedType, message?: Message): void;
declare function isNot(value: unknown, expectedType: ExpectedType, message?: Message): void;
declare function typeOf(value: unknown, expectedType: string, message?: Message): void;
declare function notTypeOf(value: unknown, expectedType: string, message?: Message): void;
declare function instanceOf(value: unknown, expectedConstructor: Function, message?: Message): void;
declare function notInstanceOf(value: unknown, expectedConstructor: Function, message?: Message): void;
declare const isNullish: (value: unknown, message?: Message) => asserts value is Nullish;
declare const isNonNullable: (value: unknown, message?: Message) => asserts value is NonNullable<unknown>;
declare const isNull: (value: unknown, message?: Message) => asserts value is null;
declare const isNotNull: (value: unknown, message?: Message) => asserts value is Exclude<unknown, null>;
declare const isUndefined: (value: unknown, message?: Message) => asserts value is undefined;
declare const isDefined: (value: unknown, message?: Message) => asserts value is Exclude<unknown, undefined>;
declare const isString: (value: unknown, message?: Message) => asserts value is string;
declare const isNotString: (value: unknown, message?: Message) => asserts value is Exclude<unknown, string>;
declare const isNumber: (value: unknown, message?: Message) => asserts value is number;
declare const isNotNumber: (value: unknown, message?: Message) => asserts value is Exclude<unknown, number>;
declare const isBigInt: (value: unknown, message?: Message) => asserts value is bigint;
declare const isNotBigInt: (value: unknown, message?: Message) => asserts value is Exclude<unknown, bigint>;
declare const isBoolean: (value: unknown, message?: Message) => asserts value is boolean;
declare const isNotBoolean: (value: unknown, message?: Message) => asserts value is Exclude<unknown, boolean>;
declare const isSymbol: (value: unknown, message?: Message) => asserts value is symbol;
declare const isNotSymbol: (value: unknown, message?: Message) => asserts value is Exclude<unknown, symbol>;
declare const isFunction: (value: unknown, message?: Message) => asserts value is Function;
declare const isNotFunction: (value: unknown, message?: Message) => asserts value is Exclude<unknown, Function>;
declare const isObject: (value: unknown, message?: Message) => asserts value is object;
declare const isNotObject: (value: unknown, message?: Message) => asserts value is Exclude<unknown, object>;
declare const isPrimitive: (value: unknown, message?: Message) => asserts value is Primitive;
declare const isNotPrimitive: (value: unknown, message?: Message) => asserts value is NonPrimitive;
declare const isNaN: (value: unknown, message?: Message) => void;
declare const isNotNaN: (value: unknown, message?: Message) => void;
declare function isInt(value: unknown, message?: Message): void;
declare function isNotInt(value: unknown, message?: Message): void;
declare function isFloat(value: unknown, message?: Message): void;
declare function isNotFloat(value: unknown, message?: Message): void;
declare function isEmpty(value: unknown, message?: Message): void;
declare function isNotEmpty(value: unknown, message?: Message): void;
declare function match(string: StringLike, regexp: RegExp, message?: Message): void;
declare function doesNotMatch(string: StringLike, regexp: RegExp, message?: Message): void;
declare function lt(value1: Comparable, value2: Comparable, message?: Message): void;
declare function lte(value1: Comparable, value2: Comparable, message?: Message): void;
declare function gt(value1: Comparable, value2: Comparable, message?: Message): void;
declare function gte(value1: Comparable, value2: Comparable, message?: Message): void;
declare function inRange(value: Comparable, min: Comparable, max: Comparable, message?: Message): void;
declare function notInRange(value: Comparable, min: Comparable, max: Comparable, message?: Message): void;
declare function stringContains(actual: StringLike, substring: StringLike, message?: Message): void;
declare function stringNotContains(actual: StringLike, substring: StringLike, message?: Message): void;
declare function stringStartsWith(actual: StringLike, substring: StringLike, message?: Message): void;
declare function stringNotStartsWith(actual: StringLike, substring: StringLike, message?: Message): void;
declare function stringEndsWith(actual: StringLike, substring: StringLike, message?: Message): void;
declare function stringNotEndsWith(actual: StringLike, substring: StringLike, message?: Message): void;
declare function includes(container: any, options: IncludesOptions, message?: Message): void;
declare function doesNotInclude(container: any, options: IncludesOptions, message?: Message): void;
declare const oneOf: (value: unknown, collection: unknown, message?: Message) => void;
declare const notOneOf: (value: unknown, collection: unknown, message?: Message) => void;
declare function operator(value1: any, operatorStr: string, value2: any, message?: Message): void;
declare function testSync<T>(name: string | undefined, block: () => T): TestResult<T>;
declare function testAsync<T>(name: string | undefined, block: () => Promise<T>): Promise<TestResult<T>>;
declare function testCheck<T>(result: TestResult<T>): result is {
    ok: true;
    value: T;
    block: Function;
    name: string;
};
declare class TestSuite {
    private readonly results;
    add(...args: Array<TestResult<any>>): this;
    clear(): this;
    get size(): number;
    success(): Iterator<TestResult<any>>;
    failed(): Iterator<TestResult<any>>;
    values(): Iterator<TestResult<any>>;
    toArray(): Array<TestResult<any>>;
    [Symbol.iterator](): Iterator<TestResult<any>>;
}
export { assert };
export default assert;
//# sourceMappingURL=assert.d.ts.map