2284.0.60.0-dev.1736515090188.js.map

{"version":3,"file":"2284.0.60.0-dev.1736515090188.js","mappings":"qRAAA,swzE","sources":["webpack:///../../node_modules/@types/chai/index.d.ts"],"sourcesContent":["export default \"// Type definitions for chai 4.3\\n// Project: http://chaijs.com/\\n// Definitions by: Jed Mao <https://github.com/jedmao>,\\n//                 Bart van der Schoor <https://github.com/Bartvds>,\\n//                 Andrew Brown <https://github.com/AGBrown>,\\n//                 Olivier Chevet <https://github.com/olivr70>,\\n//                 Matt Wistrand <https://github.com/mwistrand>,\\n//                 Shaun Luttin <https://github.com/shaunluttin>,\\n//                 Satana Charuwichitratana <https://github.com/micksatana>,\\n//                 Erik Schierboom <https://github.com/ErikSchierboom>,\\n//                 Bogdan Paranytsia <https://github.com/bparan>,\\n//                 CXuesong <https://github.com/CXuesong>,\\n//                 Joey Kilpatrick <https://github.com/joeykilpatrick>\\n// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped\\n// TypeScript Version: 3.0\\n\\ndeclare namespace Chai {\\n    type Message = string | (() => string);\\n    type ObjectProperty = string | symbol | number;\\n\\n    interface PathInfo {\\n        parent: object;\\n        name: string;\\n        value?: any;\\n        exists: boolean;\\n    }\\n\\n    interface ErrorConstructor {\\n        new(...args: any[]): Error;\\n    }\\n\\n    interface ChaiUtils {\\n        addChainableMethod(\\n            // object to define the method on, e.g. chai.Assertion.prototype\\n            ctx: object,\\n            // method name\\n            name: string,\\n            // method itself; any arguments\\n            method: (...args: any[]) => void,\\n            // called when property is accessed\\n            chainingBehavior?: () => void\\n        ): void;\\n        overwriteChainableMethod(\\n            ctx: object,\\n            name: string,\\n            method: (...args: any[]) => void,\\n            chainingBehavior?: () => void\\n        ): void;\\n        addLengthGuard(\\n            fn: Function,\\n            assertionName: string,\\n            isChainable: boolean\\n        ): void;\\n        addMethod(ctx: object, name: string, method: Function): void;\\n        addProperty(ctx: object, name: string, getter: () => any): void;\\n        overwriteMethod(ctx: object, name: string, method: Function): void;\\n        overwriteProperty(ctx: object, name: string, getter: () => any): void;\\n        compareByInspect(a: object, b: object): -1 | 1;\\n        expectTypes(obj: object, types: string[]): void;\\n        flag(obj: object, key: string, value?: any): any;\\n        getActual(obj: object, args: AssertionArgs): any;\\n        getProperties(obj: object): string[];\\n        getEnumerableProperties(obj: object): string[];\\n        getOwnEnumerablePropertySymbols(obj: object): symbol[];\\n        getOwnEnumerableProperties(obj: object): Array<string | symbol>;\\n        getMessage(errorLike: Error | string): string;\\n        getMessage(obj: any, args: AssertionArgs): string;\\n        inspect(obj: any, showHidden?: boolean, depth?: number, colors?: boolean): string;\\n        isProxyEnabled(): boolean;\\n        objDisplay(obj: object): void;\\n        proxify(obj: object, nonChainableMethodName: string): object;\\n        test(obj: object, args: AssertionArgs): boolean;\\n        transferFlags(assertion: Assertion, obj: object, includeAll?: boolean): void;\\n        compatibleInstance(thrown: Error, errorLike: Error | ErrorConstructor): boolean;\\n        compatibleConstructor(thrown: Error, errorLike: Error | ErrorConstructor): boolean;\\n        compatibleMessage(thrown: Error, errMatcher: string | RegExp): boolean;\\n        getConstructorName(constructorFn: Function): string;\\n        getFuncName(constructorFn: Function): string | null;\\n\\n        // Reexports from pathval:\\n        hasProperty(obj: object | undefined | null, name: ObjectProperty): boolean;\\n        getPathInfo(obj: object, path: string): PathInfo;\\n        getPathValue(obj: object, path: string): object | undefined;\\n    }\\n\\n    type ChaiPlugin = (chai: ChaiStatic, utils: ChaiUtils) => void;\\n\\n    interface ChaiStatic {\\n        expect: ExpectStatic;\\n        should(): Should;\\n        /**\\n         * Provides a way to extend the internals of Chai\\n         */\\n        use(fn: ChaiPlugin): ChaiStatic;\\n        util: ChaiUtils;\\n        assert: AssertStatic;\\n        config: Config;\\n        Assertion: AssertionStatic;\\n        AssertionError: typeof AssertionError;\\n        version: string;\\n    }\\n\\n    export interface ExpectStatic {\\n        (val: any, message?: string): Assertion;\\n        fail(message?: string): never;\\n        fail(actual: any, expected: any, message?: string, operator?: Operator): never;\\n    }\\n\\n    export interface AssertStatic extends Assert {\\n    }\\n\\n    // chai.Assertion.prototype.assert arguments\\n    type AssertionArgs = [\\n        // 'expression to be tested'\\n        // This parameter is unused and the docs list its type as\\n        // 'Philosophical', which is mentioned nowhere else in the source. Do\\n        // with that what you will!\\n        any,\\n        Message, // message if value fails\\n        Message, // message if negated value fails\\n        any, // expected value\\n        any?, // actual value\\n        boolean? // showDiff\\n    ];\\n\\n    export interface AssertionPrototype {\\n        assert(...args: AssertionArgs): void;\\n        _obj: any;\\n    }\\n\\n    export interface AssertionStatic extends AssertionPrototype {\\n        prototype: AssertionPrototype;\\n\\n        new(target: any, message?: string, ssfi?: Function, lockSsfi?: boolean): Assertion;\\n\\n        // Deprecated properties:\\n        includeStack: boolean;\\n        showDiff: boolean;\\n\\n        // Partials of functions on ChaiUtils:\\n        addProperty(name: string, getter: (this: AssertionStatic) => any): void;\\n        addMethod(name: string, method: (this: AssertionStatic, ...args: any[]) => any): void;\\n        addChainableMethod(\\n            name: string,\\n            method: (this: AssertionStatic, ...args: any[]) => void,\\n            chainingBehavior?: () => void\\n        ): void;\\n        overwriteProperty(name: string, getter: (this: AssertionStatic) => any): void;\\n        overwriteMethod(name: string, method: (this: AssertionStatic, ...args: any[]) => any): void;\\n        overwriteChainableMethod(\\n            name: string,\\n            method: (this: AssertionStatic, ...args: any[]) => void,\\n            chainingBehavior?: () => void\\n        ): void;\\n    }\\n\\n    export type Operator = string; // \\\"==\\\" | \\\"===\\\" | \\\">\\\" | \\\">=\\\" | \\\"<\\\" | \\\"<=\\\" | \\\"!=\\\" | \\\"!==\\\";\\n\\n    export type OperatorComparable = boolean | null | number | string | undefined | Date;\\n\\n    interface ShouldAssertion {\\n        equal(value1: any, value2: any, message?: string): void;\\n        Throw: ShouldThrow;\\n        throw: ShouldThrow;\\n        exist(value: any, message?: string): void;\\n    }\\n\\n    interface Should extends ShouldAssertion {\\n        not: ShouldAssertion;\\n        fail(message?: string): never;\\n        fail(actual: any, expected: any, message?: string, operator?: Operator): never;\\n    }\\n\\n    interface ShouldThrow {\\n        (actual: Function, expected?: string | RegExp, message?: string): void;\\n        (actual: Function, constructor: Error | Function, expected?: string | RegExp, message?: string): void;\\n    }\\n\\n    interface Assertion extends LanguageChains, NumericComparison, TypeComparison {\\n        not: Assertion;\\n        deep: Deep;\\n        ordered: Ordered;\\n        nested: Nested;\\n        own: Own;\\n        any: KeyFilter;\\n        all: KeyFilter;\\n        a: Assertion;\\n        an: Assertion;\\n        include: Include;\\n        includes: Include;\\n        contain: Include;\\n        contains: Include;\\n        ok: Assertion;\\n        true: Assertion;\\n        false: Assertion;\\n        null: Assertion;\\n        undefined: Assertion;\\n        NaN: Assertion;\\n        exist: Assertion;\\n        empty: Assertion;\\n        arguments: Assertion;\\n        Arguments: Assertion;\\n        finite: Assertion;\\n        equal: Equal;\\n        equals: Equal;\\n        eq: Equal;\\n        eql: Equal;\\n        eqls: Equal;\\n        property: Property;\\n        ownProperty: Property;\\n        haveOwnProperty: Property;\\n        ownPropertyDescriptor: OwnPropertyDescriptor;\\n        haveOwnPropertyDescriptor: OwnPropertyDescriptor;\\n        length: Length;\\n        lengthOf: Length;\\n        match: Match;\\n        matches: Match;\\n        string(string: string, message?: string): Assertion;\\n        keys: Keys;\\n        key(string: string): Assertion;\\n        throw: Throw;\\n        throws: Throw;\\n        Throw: Throw;\\n        respondTo: RespondTo;\\n        respondsTo: RespondTo;\\n        itself: Assertion;\\n        satisfy: Satisfy;\\n        satisfies: Satisfy;\\n        closeTo: CloseTo;\\n        approximately: CloseTo;\\n        members: Members;\\n        increase: PropertyChange;\\n        increases: PropertyChange;\\n        decrease: PropertyChange;\\n        decreases: PropertyChange;\\n        change: PropertyChange;\\n        changes: PropertyChange;\\n        extensible: Assertion;\\n        sealed: Assertion;\\n        frozen: Assertion;\\n        oneOf: OneOf;\\n    }\\n\\n    interface LanguageChains {\\n        to: Assertion;\\n        be: Assertion;\\n        been: Assertion;\\n        is: Assertion;\\n        that: Assertion;\\n        which: Assertion;\\n        and: Assertion;\\n        has: Assertion;\\n        have: Assertion;\\n        with: Assertion;\\n        at: Assertion;\\n        of: Assertion;\\n        same: Assertion;\\n        but: Assertion;\\n        does: Assertion;\\n    }\\n\\n    interface NumericComparison {\\n        above: NumberComparer;\\n        gt: NumberComparer;\\n        greaterThan: NumberComparer;\\n        least: NumberComparer;\\n        gte: NumberComparer;\\n        greaterThanOrEqual: NumberComparer;\\n        below: NumberComparer;\\n        lt: NumberComparer;\\n        lessThan: NumberComparer;\\n        most: NumberComparer;\\n        lte: NumberComparer;\\n        lessThanOrEqual: NumberComparer;\\n        within(start: number, finish: number, message?: string): Assertion;\\n        within(start: Date, finish: Date, message?: string): Assertion;\\n    }\\n\\n    interface NumberComparer {\\n        (value: number | Date, message?: string): Assertion;\\n    }\\n\\n    interface TypeComparison {\\n        (type: string, message?: string): Assertion;\\n        instanceof: InstanceOf;\\n        instanceOf: InstanceOf;\\n    }\\n\\n    interface InstanceOf {\\n        (constructor: any, message?: string): Assertion;\\n    }\\n\\n    interface CloseTo {\\n        (expected: number, delta: number, message?: string): Assertion;\\n    }\\n\\n    interface Nested {\\n        include: Include;\\n        includes: Include;\\n        contain: Include;\\n        contains: Include;\\n        property: Property;\\n        members: Members;\\n    }\\n\\n    interface Own {\\n        include: Include;\\n        includes: Include;\\n        contain: Include;\\n        contains: Include;\\n        property: Property;\\n    }\\n\\n    interface Deep extends KeyFilter {\\n        be: Assertion;\\n        equal: Equal;\\n        equals: Equal;\\n        eq: Equal;\\n        include: Include;\\n        includes: Include;\\n        contain: Include;\\n        contains: Include;\\n        property: Property;\\n        ordered: Ordered;\\n        nested: Nested;\\n        oneOf: OneOf;\\n        own: Own;\\n    }\\n\\n    interface Ordered {\\n        members: Members;\\n    }\\n\\n    interface KeyFilter {\\n        keys: Keys;\\n        members: Members;\\n    }\\n\\n    interface Equal {\\n        (value: any, message?: string): Assertion;\\n    }\\n\\n    interface Property {\\n        (name: string | symbol, value: any, message?: string): Assertion;\\n        (name: string | symbol, message?: string): Assertion;\\n    }\\n\\n    interface OwnPropertyDescriptor {\\n        (name: string | symbol, descriptor: PropertyDescriptor, message?: string): Assertion;\\n        (name: string | symbol, message?: string): Assertion;\\n    }\\n\\n    interface Length extends LanguageChains, NumericComparison {\\n        (length: number, message?: string): Assertion;\\n    }\\n\\n    interface Include {\\n        (value: any, message?: string): Assertion;\\n        keys: Keys;\\n        deep: Deep;\\n        ordered: Ordered;\\n        members: Members;\\n        any: KeyFilter;\\n        all: KeyFilter;\\n        oneOf: OneOf;\\n    }\\n\\n    interface OneOf {\\n        (list: ReadonlyArray<unknown>, message?: string): Assertion;\\n    }\\n\\n    interface Match {\\n        (regexp: RegExp, message?: string): Assertion;\\n    }\\n\\n    interface Keys {\\n        (...keys: string[]): Assertion;\\n        (keys: ReadonlyArray<any> | Object): Assertion;\\n    }\\n\\n    interface Throw {\\n        (expected?: string | RegExp, message?: string): Assertion;\\n        (constructor: Error | Function, expected?: string | RegExp, message?: string): Assertion;\\n    }\\n\\n    interface RespondTo {\\n        (method: string, message?: string): Assertion;\\n    }\\n\\n    interface Satisfy {\\n        (matcher: Function, message?: string): Assertion;\\n    }\\n\\n    interface Members {\\n        (set: ReadonlyArray<any>, message?: string): Assertion;\\n    }\\n\\n    interface PropertyChange {\\n        (object: Object, property?: string, message?: string): DeltaAssertion;\\n    }\\n\\n    interface DeltaAssertion extends Assertion {\\n        by(delta: number, msg?: string): Assertion;\\n    }\\n\\n    export interface Assert {\\n        /**\\n         * @param expression    Expression to test for truthiness.\\n         * @param message    Message to display on error.\\n         */\\n        (expression: any, message?: string): asserts expression;\\n\\n        /**\\n         * Throws a failure.\\n         *\\n         * @param message    Message to display on error.\\n         * @remarks Node.js assert module-compatible.\\n         */\\n        fail(message?: string): never;\\n\\n        /**\\n         * Throws a failure.\\n         *\\n         * @type T   Type of the objects.\\n         * @param actual   Actual value.\\n         * @param expected   Potential expected value.\\n         * @param message    Message to display on error.\\n         * @param operator   Comparison operator, if not strict equality.\\n         * @remarks Node.js assert module-compatible.\\n         */\\n        fail<T>(actual: T, expected: T, message?: string, operator?: Operator): never;\\n\\n        /**\\n         * Asserts that object is truthy.\\n         *\\n         * @type T   Type of object.\\n         * @param object   Object to test.\\n         * @param message    Message to display on error.\\n         */\\n        isOk<T>(value: T, message?: string): void;\\n\\n        /**\\n         * Asserts that object is truthy.\\n         *\\n         * @type T   Type of object.\\n         * @param object   Object to test.\\n         * @param message    Message to display on error.\\n         */\\n        ok<T>(value: T, message?: string): void;\\n\\n        /**\\n         * Asserts that object is falsy.\\n         *\\n         * @type T   Type of object.\\n         * @param object   Object to test.\\n         * @param message    Message to display on error.\\n         */\\n        isNotOk<T>(value: T, message?: string): void;\\n\\n        /**\\n         * Asserts that object is falsy.\\n         *\\n         * @type T   Type of object.\\n         * @param object   Object to test.\\n         * @param message    Message to display on error.\\n         */\\n        notOk<T>(value: T, message?: string): void;\\n\\n        /**\\n         * Asserts non-strict equality (==) of actual and expected.\\n         *\\n         * @type T   Type of the objects.\\n         * @param actual   Actual value.\\n         * @param expected   Potential expected value.\\n         * @param message   Message to display on error.\\n         */\\n        equal<T>(actual: T, expected: T, message?: string): void;\\n\\n        /**\\n         * Asserts non-strict inequality (!=) of actual and expected.\\n         *\\n         * @type T   Type of the objects.\\n         * @param actual   Actual value.\\n         * @param expected   Potential expected value.\\n         * @param message   Message to display on error.\\n         */\\n        notEqual<T>(actual: T, expected: T, message?: string): void;\\n\\n        /**\\n         * Asserts strict equality (===) of actual and expected.\\n         *\\n         * @type T   Type of the objects.\\n         * @param actual   Actual value.\\n         * @param expected   Potential expected value.\\n         * @param message   Message to display on error.\\n         */\\n        strictEqual<T>(actual: T, expected: T, message?: string): void;\\n\\n        /**\\n         * Asserts strict inequality (!==) of actual and expected.\\n         *\\n         * @type T   Type of the objects.\\n         * @param actual   Actual value.\\n         * @param expected   Potential expected value.\\n         * @param message   Message to display on error.\\n         */\\n        notStrictEqual<T>(actual: T, expected: T, message?: string): void;\\n\\n        /**\\n         * Asserts that actual is deeply equal to expected.\\n         *\\n         * @type T   Type of the objects.\\n         * @param actual   Actual value.\\n         * @param expected   Potential expected value.\\n         * @param message   Message to display on error.\\n         */\\n        deepEqual<T>(actual: T, expected: T, message?: string): void;\\n\\n        /**\\n         * Asserts that actual is not deeply equal to expected.\\n         *\\n         * @type T   Type of the objects.\\n         * @param actual   Actual value.\\n         * @param expected   Potential expected value.\\n         * @param message   Message to display on error.\\n         */\\n        notDeepEqual<T>(actual: T, expected: T, message?: string): void;\\n\\n        /**\\n         * Alias to deepEqual\\n         *\\n         * @type T   Type of the objects.\\n         * @param actual   Actual value.\\n         * @param expected   Potential expected value.\\n         * @param message   Message to display on error.\\n         */\\n        deepStrictEqual<T>(actual: T, expected: T, message?: string): void;\\n\\n        /**\\n         * Asserts valueToCheck is strictly greater than (>) valueToBeAbove.\\n         *\\n         * @param valueToCheck   Actual value.\\n         * @param valueToBeAbove   Minimum Potential expected value.\\n         * @param message   Message to display on error.\\n         */\\n        isAbove(valueToCheck: number, valueToBeAbove: number, message?: string): void;\\n\\n        /**\\n         * Asserts valueToCheck is greater than or equal to (>=) valueToBeAtLeast.\\n         *\\n         * @param valueToCheck   Actual value.\\n         * @param valueToBeAtLeast   Minimum Potential expected value.\\n         * @param message   Message to display on error.\\n         */\\n        isAtLeast(valueToCheck: number, valueToBeAtLeast: number, message?: string): void;\\n\\n        /**\\n         * Asserts valueToCheck is strictly less than (<) valueToBeBelow.\\n         *\\n         * @param valueToCheck   Actual value.\\n         * @param valueToBeBelow   Minimum Potential expected value.\\n         * @param message   Message to display on error.\\n         */\\n        isBelow(valueToCheck: number, valueToBeBelow: number, message?: string): void;\\n\\n        /**\\n         * Asserts valueToCheck is less than or equal to (<=) valueToBeAtMost.\\n         *\\n         * @param valueToCheck   Actual value.\\n         * @param valueToBeAtMost   Minimum Potential expected value.\\n         * @param message   Message to display on error.\\n         */\\n        isAtMost(valueToCheck: number, valueToBeAtMost: number, message?: string): void;\\n\\n        /**\\n         * Asserts that value is true.\\n         *\\n         * @type T   Type of value.\\n         * @param value   Actual value.\\n         * @param message   Message to display on error.\\n         */\\n        isTrue<T>(value: T, message?: string): void;\\n\\n        /**\\n         * Asserts that value is false.\\n         *\\n         * @type T   Type of value.\\n         * @param value   Actual value.\\n         * @param message   Message to display on error.\\n         */\\n        isFalse<T>(value: T, message?: string): void;\\n\\n        /**\\n         * Asserts that value is not true.\\n         *\\n         * @type T   Type of value.\\n         * @param value   Actual value.\\n         * @param message   Message to display on error.\\n         */\\n        isNotTrue<T>(value: T, message?: string): void;\\n\\n        /**\\n         * Asserts that value is not false.\\n         *\\n         * @type T   Type of value.\\n         * @param value   Actual value.\\n         * @param message   Message to display on error.\\n         */\\n        isNotFalse<T>(value: T, message?: string): void;\\n\\n        /**\\n         * Asserts that value is null.\\n         *\\n         * @type T   Type of value.\\n         * @param value   Actual value.\\n         * @param message   Message to display on error.\\n         */\\n        isNull<T>(value: T, message?: string): void;\\n\\n        /**\\n         * Asserts that value is not null.\\n         *\\n         * @type T   Type of value.\\n         * @param value   Actual value.\\n         * @param message   Message to display on error.\\n         */\\n        isNotNull<T>(value: T, message?: string): void;\\n\\n        /**\\n         * Asserts that value is NaN.\\n         *\\n         * @type T   Type of value.\\n         * @param value   Actual value.\\n         * @param message   Message to display on error.\\n         */\\n        isNaN<T>(value: T, message?: string): void;\\n\\n        /**\\n         * Asserts that value is not NaN.\\n         *\\n         * @type T   Type of value.\\n         * @param value   Actual value.\\n         * @param message   Message to display on error.\\n         */\\n        isNotNaN<T>(value: T, message?: string): void;\\n\\n        /**\\n         * Asserts that the target is neither null nor undefined.\\n         *\\n         * @type T   Type of value.\\n         * @param value   Actual value.\\n         * @param message    Message to display on error.\\n         */\\n        exists<T>(value: T, message?: string): void;\\n\\n        /**\\n         * Asserts that the target is either null or undefined.\\n         *\\n         * @type T   Type of value.\\n         * @param value   Actual value.\\n         * @param message    Message to display on error.\\n         */\\n        notExists<T>(value: T, message?: string): void;\\n\\n        /**\\n         * Asserts that value is undefined.\\n         *\\n         * @type T   Type of value.\\n         * @param value   Actual value.\\n         * @param message   Message to display on error.\\n         */\\n        isUndefined<T>(value: T, message?: string): void;\\n\\n        /**\\n         * Asserts that value is not undefined.\\n         *\\n         * @type T   Type of value.\\n         * @param value   Actual value.\\n         * @param message   Message to display on error.\\n         */\\n        isDefined<T>(value: T, message?: string): void;\\n\\n        /**\\n         * Asserts that value is a function.\\n         *\\n         * @type T   Type of value.\\n         * @param value   Actual value.\\n         * @param message   Message to display on error.\\n         */\\n        isFunction<T>(value: T, message?: string): void;\\n\\n        /**\\n         * Asserts that value is not a function.\\n         *\\n         * @type T   Type of value.\\n         * @param value   Actual value.\\n         * @param message   Message to display on error.\\n         */\\n        isNotFunction<T>(value: T, message?: string): void;\\n\\n        /**\\n         * Asserts that value is an object of type 'Object'\\n         * (as revealed by Object.prototype.toString).\\n         *\\n         * @type T   Type of value.\\n         * @param value   Actual value.\\n         * @param message   Message to display on error.\\n         * @remarks The assertion does not match subclassed objects.\\n         */\\n        isObject<T>(value: T, message?: string): void;\\n\\n        /**\\n         * Asserts that value is not an object of type 'Object'\\n         * (as revealed by Object.prototype.toString).\\n         *\\n         * @type T   Type of value.\\n         * @param value   Actual value.\\n         * @param message   Message to display on error.\\n         */\\n        isNotObject<T>(value: T, message?: string): void;\\n\\n        /**\\n         * Asserts that value is an array.\\n         *\\n         * @type T   Type of value.\\n         * @param value   Actual value.\\n         * @param message   Message to display on error.\\n         */\\n        isArray<T>(value: T, message?: string): void;\\n\\n        /**\\n         * Asserts that value is not an array.\\n         *\\n         * @type T   Type of value.\\n         * @param value   Actual value.\\n         * @param message   Message to display on error.\\n         */\\n        isNotArray<T>(value: T, message?: string): void;\\n\\n        /**\\n         * Asserts that value is a string.\\n         *\\n         * @type T   Type of value.\\n         * @param value   Actual value.\\n         * @param message   Message to display on error.\\n         */\\n        isString<T>(value: T, message?: string): void;\\n\\n        /**\\n         * Asserts that value is not a string.\\n         *\\n         * @type T   Type of value.\\n         * @param value   Actual value.\\n         * @param message   Message to display on error.\\n         */\\n        isNotString<T>(value: T, message?: string): void;\\n\\n        /**\\n         * Asserts that value is a number.\\n         *\\n         * @type T   Type of value.\\n         * @param value   Actual value.\\n         * @param message   Message to display on error.\\n         */\\n        isNumber<T>(value: T, message?: string): void;\\n\\n        /**\\n         * Asserts that value is not a number.\\n         *\\n         * @type T   Type of value.\\n         * @param value   Actual value.\\n         * @param message   Message to display on error.\\n         */\\n        isNotNumber<T>(value: T, message?: string): void;\\n\\n        /**\\n         * Asserts that value is a finite number.\\n         * Unlike `.isNumber`, this will fail for `NaN` and `Infinity`.\\n         *\\n         * @type T   Type of value\\n         * @param value    Actual value\\n         * @param message   Message to display on error.\\n         */\\n        isFinite<T>(value: T, message?: string): void;\\n\\n        /**\\n         * Asserts that value is a boolean.\\n         *\\n         * @type T   Type of value.\\n         * @param value   Actual value.\\n         * @param message   Message to display on error.\\n         */\\n        isBoolean<T>(value: T, message?: string): void;\\n\\n        /**\\n         * Asserts that value is not a boolean.\\n         *\\n         * @type T   Type of value.\\n         * @param value   Actual value.\\n         * @param message   Message to display on error.\\n         */\\n        isNotBoolean<T>(value: T, message?: string): void;\\n\\n        /**\\n         * Asserts that value's type is name, as determined by Object.prototype.toString.\\n         *\\n         * @type T   Type of value.\\n         * @param value   Actual value.\\n         * @param name   Potential expected type name of value.\\n         * @param message   Message to display on error.\\n         */\\n        typeOf<T>(value: T, name: string, message?: string): void;\\n\\n        /**\\n         * Asserts that value's type is not name, as determined by Object.prototype.toString.\\n         *\\n         * @type T   Type of value.\\n         * @param value   Actual value.\\n         * @param name   Potential expected type name of value.\\n         * @param message   Message to display on error.\\n         */\\n        notTypeOf<T>(value: T, name: string, message?: string): void;\\n\\n        /**\\n         * Asserts that value is an instance of constructor.\\n         *\\n         * @type T   Type of value.\\n         * @param value   Actual value.\\n         * @param constructor   Potential expected contructor of value.\\n         * @param message   Message to display on error.\\n         */\\n        instanceOf<T>(value: T, constructor: Function, message?: string): void;\\n\\n        /**\\n         * Asserts that value is not an instance of constructor.\\n         *\\n         * @type T   Type of value.\\n         * @param value   Actual value.\\n         * @param constructor   Potential expected contructor of value.\\n         * @param message   Message to display on error.\\n         */\\n        notInstanceOf<T>(value: T, type: Function, message?: string): void;\\n\\n        /**\\n         * Asserts that haystack includes needle.\\n         *\\n         * @param haystack   Container string.\\n         * @param needle   Potential substring of haystack.\\n         * @param message   Message to display on error.\\n         */\\n        include(haystack: string, needle: string, message?: string): void;\\n\\n        /**\\n         * Asserts that haystack includes needle.\\n         *\\n         * @type T   Type of values in haystack.\\n         * @param haystack   Container array, set or map.\\n         * @param needle   Potential value contained in haystack.\\n         * @param message   Message to display on error.\\n         */\\n        include<T>(haystack: ReadonlyArray<T> | ReadonlySet<T> | ReadonlyMap<any, T>, needle: T, message?: string): void;\\n\\n        /**\\n         * Asserts that haystack includes needle.\\n         *\\n         * @type T   Type of values in haystack.\\n         * @param haystack   WeakSet container.\\n         * @param needle   Potential value contained in haystack.\\n         * @param message   Message to display on error.\\n         */\\n        include<T extends object>(haystack: WeakSet<T>, needle: T, message?: string): void;\\n\\n        /**\\n         * Asserts that haystack includes needle.\\n         *\\n         * @type T   Type of haystack.\\n         * @param haystack   Object.\\n         * @param needle   Potential subset of the haystack's properties.\\n         * @param message   Message to display on error.\\n         */\\n        include<T>(haystack: T, needle: Partial<T>, message?: string): void;\\n\\n        /**\\n         * Asserts that haystack does not includes needle.\\n         *\\n         * @param haystack   Container string.\\n         * @param needle   Potential substring of haystack.\\n         * @param message   Message to display on error.\\n         */\\n        notInclude(haystack: string, needle: string, message?: string): void;\\n\\n        /**\\n         * Asserts that haystack does not includes needle.\\n         *\\n         * @type T   Type of values in haystack.\\n         * @param haystack   Container array, set or map.\\n         * @param needle   Potential value contained in haystack.\\n         * @param message   Message to display on error.\\n         */\\n        notInclude<T>(haystack: ReadonlyArray<T> | ReadonlySet<T> | ReadonlyMap<any, T>, needle: T, message?: string): void;\\n\\n        /**\\n         * Asserts that haystack does not includes needle.\\n         *\\n         * @type T   Type of values in haystack.\\n         * @param haystack   WeakSet container.\\n         * @param needle   Potential value contained in haystack.\\n         * @param message   Message to display on error.\\n         */\\n        notInclude<T extends object>(haystack: WeakSet<T>, needle: T, message?: string): void;\\n\\n        /**\\n         * Asserts that haystack does not includes needle.\\n         *\\n         * @type T   Type of haystack.\\n         * @param haystack   Object.\\n         * @param needle   Potential subset of the haystack's properties.\\n         * @param message   Message to display on error.\\n         */\\n        notInclude<T>(haystack: T, needle: Partial<T>, message?: string): void;\\n\\n        /**\\n         * Asserts that haystack includes needle. Deep equality is used.\\n         *\\n         * @param haystack   Container string.\\n         * @param needle   Potential substring of haystack.\\n         * @param message   Message to display on error.\\n         *\\n         * @deprecated Does not have any effect on string. Use {@link Assert#include} instead.\\n         */\\n        deepInclude(haystack: string, needle: string, message?: string): void;\\n\\n        /**\\n         * Asserts that haystack includes needle. Deep equality is used.\\n         *\\n         * @type T   Type of values in haystack.\\n         * @param haystack   Container array, set or map.\\n         * @param needle   Potential value contained in haystack.\\n         * @param message   Message to display on error.\\n         */\\n        deepInclude<T>(haystack: ReadonlyArray<T> | ReadonlySet<T> | ReadonlyMap<any, T>, needle: T, message?: string): void;\\n\\n        /**\\n         * Asserts that haystack does not includes needle.\\n         *\\n         * @type T   Type of haystack.\\n         * @param haystack   Object.\\n         * @param needle   Potential subset of the haystack's properties.\\n         * @param message   Message to display on error.\\n         */\\n        deepInclude<T>(haystack: T, needle: T extends WeakSet<any> ? never : Partial<T>, message?: string): void;\\n\\n        /**\\n         * Asserts that haystack does not includes needle. Deep equality is used.\\n         *\\n         * @param haystack   Container string.\\n         * @param needle   Potential substring of haystack.\\n         * @param message   Message to display on error.\\n         *\\n         * @deprecated Does not have any effect on string. Use {@link Assert#notInclude} instead.\\n         */\\n        notDeepInclude(haystack: string, needle: string, message?: string): void;\\n\\n        /**\\n         * Asserts that haystack does not includes needle. Deep equality is used.\\n         *\\n         * @type T   Type of values in haystack.\\n         * @param haystack   Container array, set or map.\\n         * @param needle   Potential value contained in haystack.\\n         * @param message   Message to display on error.\\n         */\\n        notDeepInclude<T>(haystack: ReadonlyArray<T> | ReadonlySet<T> | ReadonlyMap<any, T>, needle: T, message?: string): void;\\n\\n        /**\\n         * Asserts that haystack does not includes needle. Deep equality is used.\\n         *\\n         * @type T   Type of haystack.\\n         * @param haystack   Object.\\n         * @param needle   Potential subset of the haystack's properties.\\n         * @param message   Message to display on error.\\n         */\\n        notDeepInclude<T>(haystack: T, needle: T extends WeakSet<any> ? never : Partial<T>, message?: string): void;\\n\\n        /**\\n         * Asserts that ‘haystack’ includes ‘needle’. Can be used to assert the inclusion of a subset of properties in an object.\\n         *\\n         * Enables the use of dot- and bracket-notation for referencing nested properties.\\n         * ‘[]’ and ‘.’ in property names can be escaped using double backslashes.Asserts that ‘haystack’ includes ‘needle’.\\n         * Can be used to assert the inclusion of a subset of properties in an object.\\n         * Enables the use of dot- and bracket-notation for referencing nested properties.\\n         * ‘[]’ and ‘.’ in property names can be escaped using double backslashes.\\n         *\\n         * @param haystack\\n         * @param needle\\n         * @param message   Message to display on error.\\n         */\\n        nestedInclude(haystack: any, needle: any, message?: string): void;\\n\\n        /**\\n         * Asserts that ‘haystack’ does not include ‘needle’. Can be used to assert the absence of a subset of properties in an object.\\n         *\\n         * Enables the use of dot- and bracket-notation for referencing nested properties.\\n         * ‘[]’ and ‘.’ in property names can be escaped using double backslashes.Asserts that ‘haystack’ includes ‘needle’.\\n         * Can be used to assert the inclusion of a subset of properties in an object.\\n         * Enables the use of dot- and bracket-notation for referencing nested properties.\\n         * ‘[]’ and ‘.’ in property names can be escaped using double backslashes.\\n         *\\n         * @param haystack\\n         * @param needle\\n         * @param message   Message to display on error.\\n         */\\n        notNestedInclude(haystack: any, needle: any, message?: string): void;\\n\\n        /**\\n         * Asserts that ‘haystack’ includes ‘needle’. Can be used to assert the inclusion of a subset of properties in an object while checking for deep equality\\n         *\\n         * Enables the use of dot- and bracket-notation for referencing nested properties.\\n         * ‘[]’ and ‘.’ in property names can be escaped using double backslashes.Asserts that ‘haystack’ includes ‘needle’.\\n         * Can be used to assert the inclusion of a subset of properties in an object.\\n         * Enables the use of dot- and bracket-notation for referencing nested properties.\\n         * ‘[]’ and ‘.’ in property names can be escaped using double backslashes.\\n         *\\n         * @param haystack\\n         * @param needle\\n         * @param message   Message to display on error.\\n         */\\n        deepNestedInclude(haystack: any, needle: any, message?: string): void;\\n\\n        /**\\n         * Asserts that ‘haystack’ does not include ‘needle’. Can be used to assert the absence of a subset of properties in an object while checking for deep equality.\\n         *\\n         * Enables the use of dot- and bracket-notation for referencing nested properties.\\n         * ‘[]’ and ‘.’ in property names can be escaped using double backslashes.Asserts that ‘haystack’ includes ‘needle’.\\n         * Can be used to assert the inclusion of a subset of properties in an object.\\n         * Enables the use of dot- and bracket-notation for referencing nested properties.\\n         * ‘[]’ and ‘.’ in property names can be escaped using double backslashes.\\n         *\\n         * @param haystack\\n         * @param needle\\n         * @param message   Message to display on error.\\n         */\\n        notDeepNestedInclude(haystack: any, needle: any, message?: string): void;\\n\\n        /**\\n         * Asserts that ‘haystack’ includes ‘needle’. Can be used to assert the inclusion of a subset of properties in an object while ignoring inherited properties.\\n         *\\n         * @param haystack\\n         * @param needle\\n         * @param message   Message to display on error.\\n         */\\n        ownInclude(haystack: any, needle: any, message?: string): void;\\n\\n        /**\\n         * Asserts that ‘haystack’ includes ‘needle’. Can be used to assert the absence of a subset of properties in an object while ignoring inherited properties.\\n         *\\n         * @param haystack\\n         * @param needle\\n         * @param message   Message to display on error.\\n         */\\n        notOwnInclude(haystack: any, needle: any, message?: string): void;\\n\\n        /**\\n         * Asserts that ‘haystack’ includes ‘needle’. Can be used to assert the inclusion of a subset of properties in an object while ignoring inherited properties and checking for deep\\n         *\\n         * @param haystack\\n         * @param needle\\n         * @param message   Message to display on error.\\n         */\\n        deepOwnInclude(haystack: any, needle: any, message?: string): void;\\n\\n        /**\\n         * Asserts that ‘haystack’ includes ‘needle’. Can be used to assert the absence of a subset of properties in an object while ignoring inherited properties and checking for deep equality.\\n         *\\n         * @param haystack\\n         * @param needle\\n         * @param message   Message to display on error.\\n         */\\n        notDeepOwnInclude(haystack: any, needle: any, message?: string): void;\\n\\n        /**\\n         * Asserts that value matches the regular expression regexp.\\n         *\\n         * @param value   Actual value.\\n         * @param regexp   Potential match of value.\\n         * @param message   Message to display on error.\\n         */\\n        match(value: string, regexp: RegExp, message?: string): void;\\n\\n        /**\\n         * Asserts that value does not match the regular expression regexp.\\n         *\\n         * @param value   Actual value.\\n         * @param regexp   Potential match of value.\\n         * @param message   Message to display on error.\\n         */\\n        notMatch(expected: any, regexp: RegExp, message?: string): void;\\n\\n        /**\\n         * Asserts that object has a property named by property.\\n         *\\n         * @type T   Type of object.\\n         * @param object   Container object.\\n         * @param property   Potential contained property of object.\\n         * @param message   Message to display on error.\\n         */\\n        property<T>(object: T, property: string /* keyof T */, message?: string): void;\\n\\n        /**\\n         * Asserts that object has a property named by property.\\n         *\\n         * @type T   Type of object.\\n         * @param object   Container object.\\n         * @param property   Potential contained property of object.\\n         * @param message   Message to display on error.\\n         */\\n        notProperty<T>(object: T, property: string /* keyof T */, message?: string): void;\\n\\n        /**\\n         * Asserts that object has a property named by property, which can be a string\\n         * using dot- and bracket-notation for deep reference.\\n         *\\n         * @type T   Type of object.\\n         * @param object   Container object.\\n         * @param property   Potential contained property of object.\\n         * @param message   Message to display on error.\\n         */\\n        deepProperty<T>(object: T, property: string, message?: string): void;\\n\\n        /**\\n         * Asserts that object does not have a property named by property, which can be a\\n         * string using dot- and bracket-notation for deep reference.\\n         *\\n         * @type T   Type of object.\\n         * @param object   Container object.\\n         * @param property   Potential contained property of object.\\n         * @param message   Message to display on error.\\n         */\\n        notDeepProperty<T>(object: T, property: string, message?: string): void;\\n\\n        /**\\n         * Asserts that object has a property named by property with value given by value.\\n         *\\n         * @type T   Type of object.\\n         * @type V   Type of value.\\n         * @param object   Container object.\\n         * @param property   Potential contained property of object.\\n         * @param value   Potential expected property value.\\n         * @param message   Message to display on error.\\n         */\\n        propertyVal<T, V>(object: T, property: string /* keyof T */, value: V, message?: string): void;\\n\\n        /**\\n         * Asserts that object has a property named by property with value given by value.\\n         *\\n         * @type T   Type of object.\\n         * @type V   Type of value.\\n         * @param object   Container object.\\n         * @param property   Potential contained property of object.\\n         * @param value   Potential expected property value.\\n         * @param message   Message to display on error.\\n         */\\n        notPropertyVal<T, V>(object: T, property: string /* keyof T */, value: V, message?: string): void;\\n\\n        /**\\n         * Asserts that object has a property named by property, which can be a string\\n         * using dot- and bracket-notation for deep reference.\\n         *\\n         * @type T   Type of object.\\n         * @type V   Type of value.\\n         * @param object   Container object.\\n         * @param property   Potential contained property of object.\\n         * @param value   Potential expected property value.\\n         * @param message   Message to display on error.\\n         */\\n        deepPropertyVal<T, V>(object: T, property: string, value: V, message?: string): void;\\n\\n        /**\\n         * Asserts that object does not have a property named by property, which can be a\\n         * string using dot- and bracket-notation for deep reference.\\n         *\\n         * @type T   Type of object.\\n         * @type V   Type of value.\\n         * @param object   Container object.\\n         * @param property   Potential contained property of object.\\n         * @param value   Potential expected property value.\\n         * @param message   Message to display on error.\\n         */\\n        notDeepPropertyVal<T, V>(object: T, property: string, value: V, message?: string): void;\\n\\n        /**\\n         * Asserts that object has a length property with the expected value.\\n         *\\n         * @type T   Type of object.\\n         * @param object   Container object.\\n         * @param length   Potential expected length of object.\\n         * @param message   Message to display on error.\\n         */\\n        lengthOf<T extends { readonly length?: number | undefined }>(object: T, length: number, message?: string): void;\\n\\n        /**\\n         * Asserts that fn will throw an error.\\n         *\\n         * @param fn   Function that may throw.\\n         * @param errMsgMatcher   Expected error message matcher.\\n         * @param ignored   Ignored parameter.\\n         * @param message   Message to display on error.\\n         */\\n        throw(fn: () => void, errMsgMatcher?: RegExp | string, ignored?: any, message?: string): void;\\n\\n        /**\\n         * Asserts that fn will throw an error.\\n         *\\n         * @param fn   Function that may throw.\\n         * @param errorLike   Expected error constructor or error instance.\\n         * @param errMsgMatcher   Expected error message matcher.\\n         * @param message   Message to display on error.\\n         */\\n        throw(\\n            fn: () => void,\\n            errorLike?: ErrorConstructor | Error | null,\\n            errMsgMatcher?: RegExp | string | null,\\n            message?: string,\\n        ): void;\\n\\n        /**\\n         * Asserts that fn will throw an error.\\n         *\\n         * @param fn   Function that may throw.\\n         * @param errMsgMatcher   Expected error message matcher.\\n         * @param ignored   Ignored parameter.\\n         * @param message   Message to display on error.\\n         */\\n        throws(fn: () => void, errMsgMatcher?: RegExp | string, ignored?: any, message?: string): void;\\n\\n        /**\\n         * Asserts that fn will throw an error.\\n         *\\n         * @param fn   Function that may throw.\\n         * @param errorLike   Expected error constructor or error instance.\\n         * @param errMsgMatcher   Expected error message matcher.\\n         * @param message   Message to display on error.\\n         */\\n        throws(\\n            fn: () => void,\\n            errorLike?: ErrorConstructor | Error | null,\\n            errMsgMatcher?: RegExp | string | null,\\n            message?: string,\\n        ): void;\\n\\n        /**\\n         * Asserts that fn will throw an error.\\n         *\\n         * @param fn   Function that may throw.\\n         * @param errMsgMatcher   Expected error message matcher.\\n         * @param ignored   Ignored parameter.\\n         * @param message   Message to display on error.\\n         */\\n        Throw(fn: () => void, errMsgMatcher?: RegExp | string, ignored?: any, message?: string): void;\\n\\n        /**\\n         * Asserts that fn will throw an error.\\n         *\\n         * @param fn   Function that may throw.\\n         * @param errorLike   Expected error constructor or error instance.\\n         * @param errMsgMatcher   Expected error message matcher.\\n         * @param message   Message to display on error.\\n         */\\n        Throw(\\n            fn: () => void,\\n            errorLike?: ErrorConstructor | Error | null,\\n            errMsgMatcher?: RegExp | string | null,\\n            message?: string,\\n        ): void;\\n\\n        /**\\n         * Asserts that fn will not throw an error.\\n         *\\n         * @param fn   Function that may throw.\\n         * @param errMsgMatcher   Expected error message matcher.\\n         * @param ignored   Ignored parameter.\\n         * @param message   Message to display on error.\\n         */\\n        doesNotThrow(fn: () => void, errMsgMatcher?: RegExp | string, ignored?: any, message?: string): void;\\n\\n        /**\\n         * Asserts that fn will not throw an error.\\n         *\\n         * @param fn   Function that may throw.\\n         * @param errorLike   Expected error constructor or error instance.\\n         * @param errMsgMatcher   Expected error message matcher.\\n         * @param message   Message to display on error.\\n         */\\n        doesNotThrow(\\n            fn: () => void,\\n            errorLike?: ErrorConstructor | Error | null,\\n            errMsgMatcher?: RegExp | string | null,\\n            message?: string,\\n        ): void;\\n\\n        /**\\n         * Compares two values using operator.\\n         *\\n         * @param val1   Left value during comparison.\\n         * @param operator   Comparison operator.\\n         * @param val2   Right value during comparison.\\n         * @param message   Message to display on error.\\n         */\\n        operator(val1: OperatorComparable, operator: Operator, val2: OperatorComparable, message?: string): void;\\n\\n        /**\\n         * Asserts that the target is equal to expected, to within a +/- delta range.\\n         *\\n         * @param actual   Actual value\\n         * @param expected   Potential expected value.\\n         * @param delta   Maximum differenced between values.\\n         * @param message   Message to display on error.\\n         */\\n        closeTo(actual: number, expected: number, delta: number, message?: string): void;\\n\\n        /**\\n         * Asserts that the target is equal to expected, to within a +/- delta range.\\n         *\\n         * @param actual   Actual value\\n         * @param expected   Potential expected value.\\n         * @param delta   Maximum differenced between values.\\n         * @param message   Message to display on error.\\n         */\\n        approximately(act: number, exp: number, delta: number, message?: string): void;\\n\\n        /**\\n         * Asserts that set1 and set2 have the same members. Order is not take into account.\\n         *\\n         * @type T   Type of set values.\\n         * @param set1   Actual set of values.\\n         * @param set2   Potential expected set of values.\\n         * @param message   Message to display on error.\\n         */\\n        sameMembers<T>(set1: T[], set2: T[], message?: string): void;\\n\\n        /**\\n         * Asserts that set1 and set2 have the same members using deep equality checking.\\n         * Order is not take into account.\\n         *\\n         * @type T   Type of set values.\\n         * @param set1   Actual set of values.\\n         * @param set2   Potential expected set of values.\\n         * @param message   Message to display on error.\\n         */\\n        sameDeepMembers<T>(set1: T[], set2: T[], message?: string): void;\\n\\n        /**\\n         * Asserts that set1 and set2 have the same members in the same order.\\n         * Uses a strict equality check (===).\\n         *\\n         * @type T   Type of set values.\\n         * @param set1   Actual set of values.\\n         * @param set2   Potential expected set of values.\\n         * @param message   Message to display on error.\\n         */\\n        sameOrderedMembers<T>(set1: T[], set2: T[], message?: string): void;\\n\\n        /**\\n         * Asserts that set1 and set2 don’t have the same members in the same order.\\n         * Uses a strict equality check (===).\\n         *\\n         * @type T   Type of set values.\\n         * @param set1   Actual set of values.\\n         * @param set2   Potential expected set of values.\\n         * @param message   Message to display on error.\\n         */\\n        notSameOrderedMembers<T>(set1: T[], set2: T[], message?: string): void;\\n\\n        /**\\n         * Asserts that set1 and set2 have the same members in the same order.\\n         * Uses a deep equality check.\\n         *\\n         * @type T   Type of set values.\\n         * @param set1   Actual set of values.\\n         * @param set2   Potential expected set of values.\\n         * @param message   Message to display on error.\\n         */\\n        sameDeepOrderedMembers<T>(set1: T[], set2: T[], message?: string): void;\\n\\n        /**\\n         * Asserts that set1 and set2 don’t have the same members in the same order.\\n         * Uses a deep equality check.\\n         *\\n         * @type T   Type of set values.\\n         * @param set1   Actual set of values.\\n         * @param set2   Potential expected set of values.\\n         * @param message   Message to display on error.\\n         */\\n        notSameDeepOrderedMembers<T>(set1: T[], set2: T[], message?: string): void;\\n\\n        /**\\n         * Asserts that subset is included in superset in the same order beginning with the first element in superset.\\n         * Uses a strict equality check (===).\\n         *\\n         * @type T   Type of set values.\\n         * @param superset   Actual set of values.\\n         * @param subset   Potential contained set of values.\\n         * @param message   Message to display on error.\\n         */\\n        includeOrderedMembers<T>(superset: T[], subset: T[], message?: string): void;\\n\\n        /**\\n         * Asserts that subset isn’t included in superset in the same order beginning with the first element in superset.\\n         * Uses a strict equality check (===).\\n         *\\n         * @type T   Type of set values.\\n         * @param superset   Actual set of values.\\n         * @param subset   Potential contained set of values.\\n         * @param message   Message to display on error.\\n         */\\n        notIncludeOrderedMembers<T>(superset: T[], subset: T[], message?: string): void;\\n\\n        /**\\n         * Asserts that subset is included in superset in the same order beginning with the first element in superset.\\n         * Uses a deep equality check.\\n         *\\n         * @type T   Type of set values.\\n         * @param superset   Actual set of values.\\n         * @param subset   Potential contained set of values.\\n         * @param message   Message to display on error.\\n         */\\n        includeDeepOrderedMembers<T>(superset: T[], subset: T[], message?: string): void;\\n\\n        /**\\n         * Asserts that subset isn’t included in superset in the same order beginning with the first element in superset.\\n         * Uses a deep equality check.\\n         *\\n         * @type T   Type of set values.\\n         * @param superset   Actual set of values.\\n         * @param subset   Potential contained set of values.\\n         * @param message   Message to display on error.\\n         */\\n        notIncludeDeepOrderedMembers<T>(superset: T[], subset: T[], message?: string): void;\\n\\n        /**\\n         * Asserts that subset is included in superset. Order is not take into account.\\n         *\\n         * @type T   Type of set values.\\n         * @param superset   Actual set of values.\\n         * @param subset   Potential contained set of values.\\n         * @param message   Message to display on error.\\n         */\\n        includeMembers<T>(superset: T[], subset: T[], message?: string): void;\\n\\n        /**\\n         * Asserts that subset isn’t included in superset in any order.\\n         * Uses a strict equality check (===). Duplicates are ignored.\\n         *\\n         * @type T   Type of set values.\\n         * @param superset   Actual set of values.\\n         * @param subset   Potential not contained set of values.\\n         * @param message   Message to display on error.\\n         */\\n        notIncludeMembers<T>(superset: T[], subset: T[], message?: string): void;\\n\\n        /**\\n         * Asserts that subset is included in superset using deep equality checking.\\n         * Order is not take into account.\\n         *\\n         * @type T   Type of set values.\\n         * @param superset   Actual set of values.\\n         * @param subset   Potential contained set of values.\\n         * @param message   Message to display on error.\\n         */\\n        includeDeepMembers<T>(superset: T[], subset: T[], message?: string): void;\\n\\n        /**\\n         * Asserts that non-object, non-array value inList appears in the flat array list.\\n         *\\n         * @type T   Type of list values.\\n         * @param inList   Value expected to be in the list.\\n         * @param list   List of values.\\n         * @param message   Message to display on error.\\n         */\\n        oneOf<T>(inList: T, list: T[], message?: string): void;\\n\\n        /**\\n         * Asserts that a function changes the value of a property.\\n         *\\n         * @type T   Type of object.\\n         * @param modifier   Function to run.\\n         * @param object   Container object.\\n         * @param property   Property of object expected to be modified.\\n         * @param message   Message to display on error.\\n         */\\n        changes<T>(modifier: Function, object: T, property: string /* keyof T */, message?: string): void;\\n\\n        /**\\n         * Asserts that a function does not change the value of a property.\\n         *\\n         * @type T   Type of object.\\n         * @param modifier   Function to run.\\n         * @param object   Container object.\\n         * @param property   Property of object expected not to be modified.\\n         * @param message   Message to display on error.\\n         */\\n        doesNotChange<T>(modifier: Function, object: T, property: string /* keyof T */, message?: string): void;\\n\\n        /**\\n         * Asserts that a function increases an object property.\\n         *\\n         * @type T   Type of object.\\n         * @param modifier   Function to run.\\n         * @param object   Container object.\\n         * @param property   Property of object expected to be increased.\\n         * @param message   Message to display on error.\\n         */\\n        increases<T>(modifier: Function, object: T, property: string /* keyof T */, message?: string): void;\\n\\n        /**\\n         * Asserts that a function does not increase an object property.\\n         *\\n         * @type T   Type of object.\\n         * @param modifier   Function to run.\\n         * @param object   Container object.\\n         * @param property   Property of object expected not to be increased.\\n         * @param message   Message to display on error.\\n         */\\n        doesNotIncrease<T>(modifier: Function, object: T, property: string /* keyof T */, message?: string): void;\\n\\n        /**\\n         * Asserts that a function decreases an object property.\\n         *\\n         * @type T   Type of object.\\n         * @param modifier   Function to run.\\n         * @param object   Container object.\\n         * @param property   Property of object expected to be decreased.\\n         * @param message   Message to display on error.\\n         */\\n        decreases<T>(modifier: Function, object: T, property: string /* keyof T */, message?: string): void;\\n\\n        /**\\n         * Asserts that a function does not decrease an object property.\\n         *\\n         * @type T   Type of object.\\n         * @param modifier   Function to run.\\n         * @param object   Container object.\\n         * @param property   Property of object expected not to be decreased.\\n         * @param message   Message to display on error.\\n         */\\n        doesNotDecrease<T>(modifier: Function, object: T, property: string /* keyof T */, message?: string): void;\\n\\n        /**\\n         * Asserts if value is not a false value, and throws if it is a true value.\\n         *\\n         * @type T   Type of object.\\n         * @param object   Actual value.\\n         * @param message   Message to display on error.\\n         * @remarks This is added to allow for chai to be a drop-in replacement for\\n         *          Node’s assert class.\\n         */\\n        ifError<T>(object: T, message?: string): void;\\n\\n        /**\\n         * Asserts that object is extensible (can have new properties added to it).\\n         *\\n         * @type T   Type of object\\n         * @param object   Actual value.\\n         * @param message   Message to display on error.\\n         */\\n        isExtensible<T>(object: T, message?: string): void;\\n\\n        /**\\n         * Asserts that object is extensible (can have new properties added to it).\\n         *\\n         * @type T   Type of object\\n         * @param object   Actual value.\\n         * @param message   Message to display on error.\\n         */\\n        extensible<T>(object: T, message?: string): void;\\n\\n        /**\\n         * Asserts that object is not extensible.\\n         *\\n         * @type T   Type of object\\n         * @param object   Actual value.\\n         * @param message   Message to display on error.\\n         */\\n        isNotExtensible<T>(object: T, message?: string): void;\\n\\n        /**\\n         * Asserts that object is not extensible.\\n         *\\n         * @type T   Type of object\\n         * @param object   Actual value.\\n         * @param message   Message to display on error.\\n         */\\n        notExtensible<T>(object: T, message?: string): void;\\n\\n        /**\\n         * Asserts that object is sealed (can have new properties added to it\\n         * and its existing properties cannot be removed).\\n         *\\n         * @type T   Type of object\\n         * @param object   Actual value.\\n         * @param message   Message to display on error.\\n         */\\n        isSealed<T>(object: T, message?: string): void;\\n\\n        /**\\n         * Asserts that object is sealed (can have new properties added to it\\n         * and its existing properties cannot be removed).\\n         *\\n         * @type T   Type of object\\n         * @param object   Actual value.\\n         * @param message   Message to display on error.\\n         */\\n        sealed<T>(object: T, message?: string): void;\\n\\n        /**\\n         * Asserts that object is not sealed.\\n         *\\n         * @type T   Type of object\\n         * @param object   Actual value.\\n         * @param message   Message to display on error.\\n         */\\n        isNotSealed<T>(object: T, message?: string): void;\\n\\n        /**\\n         * Asserts that object is not sealed.\\n         *\\n         * @type T   Type of object\\n         * @param object   Actual value.\\n         * @param message   Message to display on error.\\n         */\\n        notSealed<T>(object: T, message?: string): void;\\n\\n        /**\\n         * Asserts that object is frozen (cannot have new properties added to it\\n         * and its existing properties cannot be removed).\\n         *\\n         * @type T   Type of object\\n         * @param object   Actual value.\\n         * @param message   Message to display on error.\\n         */\\n        isFrozen<T>(object: T, message?: string): void;\\n\\n        /**\\n         * Asserts that object is frozen (cannot have new properties added to it\\n         * and its existing properties cannot be removed).\\n         *\\n         * @type T   Type of object\\n         * @param object   Actual value.\\n         * @param message   Message to display on error.\\n         */\\n        frozen<T>(object: T, message?: string): void;\\n\\n        /**\\n         * Asserts that object is not frozen (cannot have new properties added to it\\n         * and its existing properties cannot be removed).\\n         *\\n         * @type T   Type of object\\n         * @param object   Actual value.\\n         * @param message   Message to display on error.\\n         */\\n        isNotFrozen<T>(object: T, message?: string): void;\\n\\n        /**\\n         * Asserts that object is not frozen (cannot have new properties added to it\\n         * and its existing properties cannot be removed).\\n         *\\n         * @type T   Type of object\\n         * @param object   Actual value.\\n         * @param message   Message to display on error.\\n         */\\n        notFrozen<T>(object: T, message?: string): void;\\n\\n        /**\\n         * Asserts that the target does not contain any values. For arrays and\\n         * strings, it checks the length property. For Map and Set instances, it\\n         * checks the size property. For non-function objects, it gets the count\\n         * of own enumerable string keys.\\n         *\\n         * @type T   Type of object\\n         * @param object   Actual value.\\n         * @param message   Message to display on error.\\n         */\\n        isEmpty<T>(object: T, message?: string): void;\\n\\n        /**\\n         * Asserts that the target contains values. For arrays and strings, it checks\\n         * the length property. For Map and Set instances, it checks the size property.\\n         * For non-function objects, it gets the count of own enumerable string keys.\\n         *\\n         * @type T   Type of object.\\n         * @param object   Object to test.\\n         * @param message    Message to display on error.\\n         */\\n        isNotEmpty<T>(object: T, message?: string): void;\\n\\n        /**\\n         * Asserts that `object` has at least one of the `keys` provided.\\n         * You can also provide a single object instead of a `keys` array and its keys\\n         * will be used as the expected set of keys.\\n         *\\n         * @type T   Type of object.\\n         * @param object   Object to test.\\n         * @param keys   Keys to check\\n         * @param message    Message to display on error.\\n         */\\n        hasAnyKeys<T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string): void;\\n\\n        /**\\n         * Asserts that `object` has all and only all of the `keys` provided.\\n         * You can also provide a single object instead of a `keys` array and its keys\\n         * will be used as the expected set of keys.\\n         *\\n         * @type T   Type of object.\\n         * @param object   Object to test.\\n         * @param keys   Keys to check\\n         * @param message    Message to display on error.\\n         */\\n        hasAllKeys<T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string): void;\\n\\n        /**\\n         * Asserts that `object` has all of the `keys` provided but may have more keys not listed.\\n         * You can also provide a single object instead of a `keys` array and its keys\\n         * will be used as the expected set of keys.\\n         *\\n         * @type T   Type of object.\\n         * @param object   Object to test.\\n         * @param keys   Keys to check\\n         * @param message    Message to display on error.\\n         */\\n        containsAllKeys<T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string): void;\\n\\n        /**\\n         * Asserts that `object` has none of the `keys` provided.\\n         * You can also provide a single object instead of a `keys` array and its keys\\n         * will be used as the expected set of keys.\\n         *\\n         * @type T   Type of object.\\n         * @param object   Object to test.\\n         * @param keys   Keys to check\\n         * @param message    Message to display on error.\\n         */\\n        doesNotHaveAnyKeys<T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string): void;\\n\\n        /**\\n         * Asserts that `object` does not have at least one of the `keys` provided.\\n         * You can also provide a single object instead of a `keys` array and its keys\\n         * will be used as the expected set of keys.\\n         *\\n         * @type T   Type of object.\\n         * @param object   Object to test.\\n         * @param keys   Keys to check\\n         * @param message    Message to display on error.\\n         */\\n        doesNotHaveAllKeys<T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string): void;\\n\\n        /**\\n         * Asserts that `object` has at least one of the `keys` provided.\\n         * Since Sets and Maps can have objects as keys you can use this assertion to perform\\n         * a deep comparison.\\n         * You can also provide a single object instead of a `keys` array and its keys\\n         * will be used as the expected set of keys.\\n         *\\n         * @type T   Type of object.\\n         * @param object   Object to test.\\n         * @param keys   Keys to check\\n         * @param message    Message to display on error.\\n         */\\n        hasAnyDeepKeys<T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string): void;\\n\\n        /**\\n         * Asserts that `object` has all and only all of the `keys` provided.\\n         * Since Sets and Maps can have objects as keys you can use this assertion to perform\\n         * a deep comparison.\\n         * You can also provide a single object instead of a `keys` array and its keys\\n         * will be used as the expected set of keys.\\n         *\\n         * @type T   Type of object.\\n         * @param object   Object to test.\\n         * @param keys   Keys to check\\n         * @param message    Message to display on error.\\n         */\\n        hasAllDeepKeys<T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string): void;\\n\\n        /**\\n         * Asserts that `object` contains all of the `keys` provided.\\n         * Since Sets and Maps can have objects as keys you can use this assertion to perform\\n         * a deep comparison.\\n         * You can also provide a single object instead of a `keys` array and its keys\\n         * will be used as the expected set of keys.\\n         *\\n         * @type T   Type of object.\\n         * @param object   Object to test.\\n         * @param keys   Keys to check\\n         * @param message    Message to display on error.\\n         */\\n        containsAllDeepKeys<T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string): void;\\n\\n        /**\\n         * Asserts that `object` contains all of the `keys` provided.\\n         * Since Sets and Maps can have objects as keys you can use this assertion to perform\\n         * a deep comparison.\\n         * You can also provide a single object instead of a `keys` array and its keys\\n         * will be used as the expected set of keys.\\n         *\\n         * @type T   Type of object.\\n         * @param object   Object to test.\\n         * @param keys   Keys to check\\n         * @param message    Message to display on error.\\n         */\\n        doesNotHaveAnyDeepKeys<T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string): void;\\n\\n        /**\\n         * Asserts that `object` contains all of the `keys` provided.\\n         * Since Sets and Maps can have objects as keys you can use this assertion to perform\\n         * a deep comparison.\\n         * You can also provide a single object instead of a `keys` array and its keys\\n         * will be used as the expected set of keys.\\n         *\\n         * @type T   Type of object.\\n         * @param object   Object to test.\\n         * @param keys   Keys to check\\n         * @param message    Message to display on error.\\n         */\\n        doesNotHaveAllDeepKeys<T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string): void;\\n\\n        /**\\n         * Asserts that object has a direct or inherited property named by property,\\n         * which can be a string using dot- and bracket-notation for nested reference.\\n         *\\n         * @type T   Type of object.\\n         * @param object   Object to test.\\n         * @param property    Property to test.\\n         * @param message    Message to display on error.\\n         */\\n        nestedProperty<T>(object: T, property: string, message?: string): void;\\n\\n        /**\\n         * Asserts that object does not have a property named by property,\\n         * which can be a string using dot- and bracket-notation for nested reference.\\n         * The property cannot exist on the object nor anywhere in its prototype chain.\\n         *\\n         * @type T   Type of object.\\n         * @param object   Object to test.\\n         * @param property    Property to test.\\n         * @param message    Message to display on error.\\n         */\\n        notNestedProperty<T>(object: T, property: string, message?: string): void;\\n\\n        /**\\n         * Asserts that object has a property named by property with value given by value.\\n         * property can use dot- and bracket-notation for nested reference. Uses a strict equality check (===).\\n         *\\n         * @type T   Type of object.\\n         * @param object   Object to test.\\n         * @param property    Property to test.\\n         * @param value    Value to test.\\n         * @param message    Message to display on error.\\n         */\\n        nestedPropertyVal<T>(object: T, property: string, value: any, message?: string): void;\\n\\n        /**\\n         * Asserts that object does not have a property named by property with value given by value.\\n         * property can use dot- and bracket-notation for nested reference. Uses a strict equality check (===).\\n         *\\n         * @type T   Type of object.\\n         * @param object   Object to test.\\n         * @param property    Property to test.\\n         * @param value    Value to test.\\n         * @param message    Message to display on error.\\n         */\\n        notNestedPropertyVal<T>(object: T, property: string, value: any, message?: string): void;\\n\\n        /**\\n         * Asserts that object has a property named by property with a value given by value.\\n         * property can use dot- and bracket-notation for nested reference. Uses a deep equality check.\\n         *\\n         * @type T   Type of object.\\n         * @param object   Object to test.\\n         * @param property    Property to test.\\n         * @param value    Value to test.\\n         * @param message    Message to display on error.\\n         */\\n        deepNestedPropertyVal<T>(object: T, property: string, value: any, message?: string): void;\\n\\n        /**\\n         * Asserts that object does not have a property named by property with value given by value.\\n         * property can use dot- and bracket-notation for nested reference. Uses a deep equality check.\\n         *\\n         * @type T   Type of object.\\n         * @param object   Object to test.\\n         * @param property    Property to test.\\n         * @param value    Value to test.\\n         * @param message    Message to display on error.\\n         */\\n        notDeepNestedPropertyVal<T>(object: T, property: string, value: any, message?: string): void;\\n    }\\n\\n    export interface Config {\\n        /**\\n         * Default: false\\n         */\\n        includeStack: boolean;\\n\\n        /**\\n         * Default: true\\n         */\\n        showDiff: boolean;\\n\\n        /**\\n         * Default: 40\\n         */\\n        truncateThreshold: number;\\n\\n        /**\\n         * Default: true\\n         */\\n        useProxy: boolean;\\n\\n        /**\\n         * Default: ['then', 'catch', 'inspect', 'toJSON']\\n         */\\n        proxyExcludedKeys: string[];\\n    }\\n\\n    export class AssertionError {\\n        constructor(message: string, _props?: any, ssf?: Function);\\n        name: string;\\n        message: string;\\n        showDiff: boolean;\\n        stack: string;\\n    }\\n}\\n\\ndeclare const chai: Chai.ChaiStatic;\\n\\ndeclare module \\\"chai\\\" {\\n    export = chai;\\n}\\n\\ninterface Object {\\n    should: Chai.Assertion;\\n}\\n\";"],"names":[],"sourceRoot":""}