chai/000755 001751 000166 0000000000 15006227306013436 5ustar00runner000000 000000 1500622730615006227306chai/LICENSE000644 001751 000166 0000002165 15006227306014447 0ustar00runner000000 000000 1500622730615006227306 MIT License Copyright (c) Microsoft Corporation. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE chai/README.md000644 001751 000166 0000001663 15006227306014724 0ustar00runner000000 000000 1500622731615006227306# Installation > `npm install --save @types/chai` # Summary This package contains type definitions for chai (http://chaijs.com/). # Details Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/chai. ### Additional Details * Last updated: Mon, 05 May 2025 21:33:58 GMT * Dependencies: [@types/deep-eql](https://npmjs.com/package/@types/deep-eql) # Credits These definitions were written by [Bart van der Schoor](https://github.com/Bartvds), [Andrew Brown](https://github.com/AGBrown), [Olivier Chevet](https://github.com/olivr70), [Matt Wistrand](https://github.com/mwistrand), [Shaun Luttin](https://github.com/shaunluttin), [Satana Charuwichitratana](https://github.com/micksatana), [Erik Schierboom](https://github.com/ErikSchierboom), [Bogdan Paranytsia](https://github.com/bparan), [CXuesong](https://github.com/CXuesong), and [Joey Kilpatrick](https://github.com/joeykilpatrick). chai/index.d.ts000644 001751 000166 0000252313 15006227306015345 0ustar00runner000000 000000 1500622730615006227306import deepEqual = require("deep-eql"); declare global { namespace Chai { type Message = string | (() => string); type ObjectProperty = string | symbol | number; interface PathInfo { parent: object; name: string; value?: any; exists: boolean; } interface Constructor { new(...args: any[]): T; } interface ErrorConstructor { new(...args: any[]): Error; } interface ChaiUtils { addChainableMethod( // object to define the method on, e.g. chai.Assertion.prototype ctx: object, // method name name: string, // method itself; any arguments method: (...args: any[]) => void, // called when property is accessed chainingBehavior?: () => void, ): void; overwriteChainableMethod( ctx: object, name: string, method: (...args: any[]) => void, chainingBehavior?: () => void, ): void; addLengthGuard( fn: Function, assertionName: string, isChainable: boolean, ): void; addMethod(ctx: object, name: string, method: Function): void; addProperty(ctx: object, name: string, getter: () => any): void; overwriteMethod(ctx: object, name: string, method: Function): void; overwriteProperty(ctx: object, name: string, getter: (this: AssertionStatic, _super: any) => any): void; compareByInspect(a: object, b: object): -1 | 1; expectTypes(obj: object, types: string[]): void; flag(obj: object, key: string, value?: any): any; getActual(obj: object, args: AssertionArgs): any; getProperties(obj: object): string[]; getEnumerableProperties(obj: object): string[]; getOwnEnumerablePropertySymbols(obj: object): symbol[]; getOwnEnumerableProperties(obj: object): Array; getMessage(errorLike: Error | string): string; getMessage(obj: any, args: AssertionArgs): string; inspect(obj: any, showHidden?: boolean, depth?: number, colors?: boolean): string; isProxyEnabled(): boolean; objDisplay(obj: object): void; proxify(obj: object, nonChainableMethodName: string): object; test(obj: object, args: AssertionArgs): boolean; transferFlags(assertion: Assertion, obj: object, includeAll?: boolean): void; compatibleInstance(thrown: Error, errorLike: Error | ErrorConstructor): boolean; compatibleConstructor(thrown: Error, errorLike: Error | ErrorConstructor): boolean; compatibleMessage(thrown: Error, errMatcher: string | RegExp): boolean; getConstructorName(constructorFn: Function): string; getFuncName(constructorFn: Function): string | null; // Reexports from pathval: hasProperty(obj: object | undefined | null, name: ObjectProperty): boolean; getPathInfo(obj: object, path: string): PathInfo; getPathValue(obj: object, path: string): object | undefined; eql: typeof deepEqual; } type ChaiPlugin = (chai: ChaiStatic, utils: ChaiUtils) => void; interface ChaiStatic { expect: ExpectStatic; should(): Should; /** * Provides a way to extend the internals of Chai */ use(fn: ChaiPlugin): ChaiStatic; util: ChaiUtils; assert: AssertStatic; config: Config; Assertion: AssertionStatic; AssertionError: typeof AssertionError; version: string; } export interface ExpectStatic { (val: any, message?: string): Assertion; fail(message?: string): never; fail(actual: any, expected: any, message?: string, operator?: Operator): never; } export interface AssertStatic extends Assert { } // chai.Assertion.prototype.assert arguments type AssertionArgs = [ any, // expression to be tested Message, // message or function that returns message to display if expression fails Message, // negatedMessage or function that returns negatedMessage to display if expression fails any?, // expected value any?, // actual value boolean?, // showDiff, when set to `true`, assert will display a diff in addition to the message if expression fails ]; export interface AssertionPrototype { assert(...args: AssertionArgs): void; _obj: any; } export interface AssertionStatic extends AssertionPrototype { prototype: AssertionPrototype; new(target: any, message?: string, ssfi?: Function, lockSsfi?: boolean): Assertion; // Deprecated properties: includeStack: boolean; showDiff: boolean; // Partials of functions on ChaiUtils: addProperty(name: string, getter: (this: AssertionStatic) => any): void; addMethod(name: string, method: (this: AssertionStatic, ...args: any[]) => any): void; addChainableMethod( name: string, method: (this: AssertionStatic, ...args: any[]) => void, chainingBehavior?: () => void, ): void; overwriteProperty(name: string, getter: (this: AssertionStatic, _super: any) => any): void; overwriteMethod(name: string, method: (this: AssertionStatic, ...args: any[]) => any): void; overwriteChainableMethod( name: string, method: (this: AssertionStatic, ...args: any[]) => void, chainingBehavior?: () => void, ): void; } export type Operator = string; // "==" | "===" | ">" | ">=" | "<" | "<=" | "!=" | "!=="; export type OperatorComparable = boolean | null | number | string | undefined | Date; interface ShouldAssertion { equal(value1: any, value2: any, message?: string): void; Throw: ShouldThrow; throw: ShouldThrow; exist(value: any, message?: string): void; } interface Should extends ShouldAssertion { not: ShouldAssertion; fail(message?: string): never; fail(actual: any, expected: any, message?: string, operator?: Operator): never; } interface ShouldThrow { (actual: Function, expected?: string | RegExp, message?: string): void; (actual: Function, constructor: Error | Function, expected?: string | RegExp, message?: string): void; } interface Assertion extends LanguageChains, NumericComparison, TypeComparison { not: Assertion; deep: Deep; ordered: Ordered; nested: Nested; own: Own; any: KeyFilter; all: KeyFilter; a: Assertion; an: Assertion; include: Include; includes: Include; contain: Include; contains: Include; ok: Assertion; true: Assertion; false: Assertion; null: Assertion; undefined: Assertion; NaN: Assertion; exist: Assertion; empty: Assertion; arguments: Assertion; Arguments: Assertion; finite: Assertion; equal: Equal; equals: Equal; eq: Equal; eql: Equal; eqls: Equal; containSubset: ContainSubset; property: Property; ownProperty: Property; haveOwnProperty: Property; ownPropertyDescriptor: OwnPropertyDescriptor; haveOwnPropertyDescriptor: OwnPropertyDescriptor; length: Length; lengthOf: Length; match: Match; matches: Match; string(string: string, message?: string): Assertion; keys: Keys; key(string: string): Assertion; throw: Throw; throws: Throw; Throw: Throw; respondTo: RespondTo; respondsTo: RespondTo; itself: Assertion; satisfy: Satisfy; satisfies: Satisfy; closeTo: CloseTo; approximately: CloseTo; members: Members; increase: PropertyChange; increases: PropertyChange; decrease: PropertyChange; decreases: PropertyChange; change: PropertyChange; changes: PropertyChange; extensible: Assertion; sealed: Assertion; frozen: Assertion; oneOf: OneOf; } interface LanguageChains { to: Assertion; be: Assertion; been: Assertion; is: Assertion; that: Assertion; which: Assertion; and: Assertion; has: Assertion; have: Assertion; with: Assertion; at: Assertion; of: Assertion; same: Assertion; but: Assertion; does: Assertion; } interface NumericComparison { above: NumberComparer; gt: NumberComparer; greaterThan: NumberComparer; least: NumberComparer; gte: NumberComparer; greaterThanOrEqual: NumberComparer; below: NumberComparer; lt: NumberComparer; lessThan: NumberComparer; most: NumberComparer; lte: NumberComparer; lessThanOrEqual: NumberComparer; within(start: number, finish: number, message?: string): Assertion; within(start: Date, finish: Date, message?: string): Assertion; } interface NumberComparer { (value: number | Date, message?: string): Assertion; } interface TypeComparison { (type: string, message?: string): Assertion; instanceof: InstanceOf; instanceOf: InstanceOf; } interface InstanceOf { (constructor: any, message?: string): Assertion; } interface CloseTo { (expected: number, delta: number, message?: string): Assertion; } interface Nested { include: Include; includes: Include; contain: Include; contains: Include; property: Property; members: Members; } interface Own { include: Include; includes: Include; contain: Include; contains: Include; property: Property; } interface Deep extends KeyFilter { be: Assertion; equal: Equal; equals: Equal; eq: Equal; include: Include; includes: Include; contain: Include; contains: Include; property: Property; ordered: Ordered; nested: Nested; oneOf: OneOf; own: Own; } interface Ordered { members: Members; } interface KeyFilter { keys: Keys; members: Members; } interface Equal { (value: any, message?: string): Assertion; } interface ContainSubset { (expected: any): Assertion; } interface Property { (name: string | symbol, value: any, message?: string): Assertion; (name: string | symbol, message?: string): Assertion; } interface OwnPropertyDescriptor { (name: string | symbol, descriptor: PropertyDescriptor, message?: string): Assertion; (name: string | symbol, message?: string): Assertion; } interface Length extends LanguageChains, NumericComparison { (length: number, message?: string): Assertion; } interface Include { (value: any, message?: string): Assertion; keys: Keys; deep: Deep; ordered: Ordered; members: Members; any: KeyFilter; all: KeyFilter; oneOf: OneOf; } interface OneOf { (list: readonly unknown[], message?: string): Assertion; } interface Match { (regexp: RegExp, message?: string): Assertion; } interface Keys { (...keys: string[]): Assertion; (keys: readonly any[] | Object): Assertion; } interface Throw { (expected?: string | RegExp, message?: string): Assertion; (constructor: Error | Function, expected?: string | RegExp, message?: string): Assertion; } interface RespondTo { (method: string, message?: string): Assertion; } interface Satisfy { (matcher: Function, message?: string): Assertion; } interface Members { (set: readonly any[], message?: string): Assertion; } interface PropertyChange { (object: Object, property?: string, message?: string): DeltaAssertion; } interface DeltaAssertion extends Assertion { by(delta: number, msg?: string): Assertion; } export interface Assert { /** * @param expression Expression to test for truthiness. * @param message Message to display on error. */ (expression: any, message?: string): asserts expression; /** * Throws a failure. * * @param message Message to display on error. * @remarks Node.js assert module-compatible. */ fail(message?: string): never; /** * Throws a failure. * * T Type of the objects. * @param actual Actual value. * @param expected Potential expected value. * @param message Message to display on error. * @param operator Comparison operator, if not strict equality. * @remarks Node.js assert module-compatible. */ fail(actual: T, expected: T, message?: string, operator?: Operator): never; /** * Asserts that object is truthy. * * @param object Object to test. * @param message Message to display on error. */ isOk(value: unknown, message?: string): asserts value; /** * Asserts that object is truthy. * * @param object Object to test. * @param message Message to display on error. */ ok(value: unknown, message?: string): asserts value; /** * Asserts that object is falsy. * * T Type of object. * @param object Object to test. * @param message Message to display on error. */ isNotOk(value: T, message?: string): void; /** * Asserts that object is falsy. * * T Type of object. * @param object Object to test. * @param message Message to display on error. */ notOk(value: T, message?: string): void; /** * Asserts non-strict equality (==) of actual and expected. * * T Type of the objects. * @param actual Actual value. * @param expected Potential expected value. * @param message Message to display on error. */ equal(actual: T, expected: T, message?: string): void; /** * Asserts non-strict inequality (!=) of actual and expected. * * T Type of the objects. * @param actual Actual value. * @param expected Potential expected value. * @param message Message to display on error. */ notEqual(actual: T, expected: T, message?: string): void; /** * Asserts strict equality (===) of actual and expected. * * T Type of the objects. * @param actual Actual value. * @param expected Potential expected value. * @param message Message to display on error. */ strictEqual(actual: T, expected: T, message?: string): void; /** * Asserts strict inequality (!==) of actual and expected. * * T Type of the objects. * @param actual Actual value. * @param expected Potential expected value. * @param message Message to display on error. */ notStrictEqual(actual: T, expected: T, message?: string): void; /** * Asserts that actual is deeply equal to expected. * * T Type of the objects. * @param actual Actual value. * @param expected Potential expected value. * @param message Message to display on error. */ deepEqual(actual: T, expected: T, message?: string): void; /** * Asserts that actual is not deeply equal to expected. * * T Type of the objects. * @param actual Actual value. * @param expected Potential expected value. * @param message Message to display on error. */ notDeepEqual(actual: T, expected: T, message?: string): void; /** * Alias to deepEqual * * T Type of the objects. * @param actual Actual value. * @param expected Potential expected value. * @param message Message to display on error. */ deepStrictEqual(actual: T, expected: T, message?: string): void; /** * Partially matches actual and expected. * * @param actual Actual value. * @param expected Potential subset of the value. * @param message Message to display on error. */ containSubset(val: any, exp: any, msg?: string): void; /** * Partially matches actual and expected. * * @param actual Actual value. * @param expected Potential subset of the value. * @param message Message to display on error. */ containsSubset(val: any, exp: any, msg?: string): void; /** * No partial match between actual and expected exists. * * @param actual Actual value. * @param expected Potential subset of the value. * @param message Message to display on error. */ doesNotContainSubset(val: any, exp: any, msg?: string): void; /** * Asserts valueToCheck is strictly greater than (>) valueToBeAbove. * * @param valueToCheck Actual value. * @param valueToBeAbove Minimum Potential expected value. * @param message Message to display on error. */ isAbove(valueToCheck: number, valueToBeAbove: number, message?: string): void; /** * Asserts valueToCheck is greater than or equal to (>=) valueToBeAtLeast. * * @param valueToCheck Actual value. * @param valueToBeAtLeast Minimum Potential expected value. * @param message Message to display on error. */ isAtLeast(valueToCheck: number, valueToBeAtLeast: number, message?: string): void; /** * Asserts valueToCheck is strictly less than (<) valueToBeBelow. * * @param valueToCheck Actual value. * @param valueToBeBelow Minimum Potential expected value. * @param message Message to display on error. */ isBelow(valueToCheck: number, valueToBeBelow: number, message?: string): void; /** * Asserts valueToCheck is less than or equal to (<=) valueToBeAtMost. * * @param valueToCheck Actual value. * @param valueToBeAtMost Minimum Potential expected value. * @param message Message to display on error. */ isAtMost(valueToCheck: number, valueToBeAtMost: number, message?: string): void; /** * Asserts that value is true. * * @param value Actual value. * @param message Message to display on error. */ isTrue(value: unknown, message?: string): asserts value is true; /** * Asserts that value is false. * * @param value Actual value. * @param message Message to display on error. */ isFalse(value: unknown, message?: string): asserts value is false; /** * Asserts that value is not true. * * T Type of value. * @param value Actual value. * @param message Message to display on error. */ isNotTrue(value: T, message?: string): asserts value is Exclude; /** * Asserts that value is not false. * * @param value Actual value. * @param message Message to display on error. */ isNotFalse(value: T, message?: string): asserts value is Exclude; /** * Asserts that value is null. * * @param value Actual value. * @param message Message to display on error. */ isNull(value: unknown, message?: string): asserts value is null; /** * Asserts that value is not null. * * T Type of value. * @param value Actual value. * @param message Message to display on error. */ isNotNull(value: T, message?: string): asserts value is Exclude; /** * Asserts that value is NaN. * * T Type of value. * @param value Actual value. * @param message Message to display on error. */ isNaN(value: T, message?: string): void; /** * Asserts that value is not NaN. * * T Type of value. * @param value Actual value. * @param message Message to display on error. */ isNotNaN(value: T, message?: string): void; /** * Asserts that the target is neither null nor undefined. * * T Type of value. * @param value Actual value. * @param message Message to display on error. */ exists(value: T, message?: string): asserts value is NonNullable; /** * Asserts that the target is either null or undefined. * * @param value Actual value. * @param message Message to display on error. */ notExists(value: unknown, message?: string): asserts value is | null | undefined; /** * Asserts that value is undefined. * * @param value Actual value. * @param message Message to display on error. */ isUndefined(value: unknown, message?: string): asserts value is undefined; /** * Asserts that value is not undefined. * * T Type of value. * @param value Actual value. * @param message Message to display on error. */ isDefined(value: T, message?: string): asserts value is Exclude; /** * Asserts that value is a function. * * T Type of value. * @param value Actual value. * @param message Message to display on error. */ isFunction(value: T, message?: string): void; /** * Asserts that value is not a function. * * T Type of value. * @param value Actual value. * @param message Message to display on error. */ isNotFunction(value: T, message?: string): void; /** * Asserts that value is an object of type 'Object' * (as revealed by Object.prototype.toString). * * T Type of value. * @param value Actual value. * @param message Message to display on error. * @remarks The assertion does not match subclassed objects. */ isObject(value: T, message?: string): void; /** * Asserts that value is not an object of type 'Object' * (as revealed by Object.prototype.toString). * * T Type of value. * @param value Actual value. * @param message Message to display on error. */ isNotObject(value: T, message?: string): void; /** * Asserts that value is an array. * * T Type of value. * @param value Actual value. * @param message Message to display on error. */ isArray(value: T, message?: string): void; /** * Asserts that value is not an array. * * T Type of value. * @param value Actual value. * @param message Message to display on error. */ isNotArray(value: T, message?: string): void; /** * Asserts that value is a string. * * T Type of value. * @param value Actual value. * @param message Message to display on error. */ isString(value: T, message?: string): void; /** * Asserts that value is not a string. * * T Type of value. * @param value Actual value. * @param message Message to display on error. */ isNotString(value: T, message?: string): void; /** * Asserts that value is a number. * * T Type of value. * @param value Actual value. * @param message Message to display on error. */ isNumber(value: T, message?: string): void; /** * Asserts that value is not a number. * * T Type of value. * @param value Actual value. * @param message Message to display on error. */ isNotNumber(value: T, message?: string): void; /** * Asserts that value is a finite number. * Unlike `.isNumber`, this will fail for `NaN` and `Infinity`. * * T Type of value * @param value Actual value * @param message Message to display on error. */ isFinite(value: T, message?: string): void; /** * Asserts that value is a boolean. * * T Type of value. * @param value Actual value. * @param message Message to display on error. */ isBoolean(value: T, message?: string): void; /** * Asserts that value is not a boolean. * * T Type of value. * @param value Actual value. * @param message Message to display on error. */ isNotBoolean(value: T, message?: string): void; /** * Asserts that value's type is name, as determined by Object.prototype.toString. * * T Type of value. * @param value Actual value. * @param name Potential expected type name of value. * @param message Message to display on error. */ typeOf(value: T, name: string, message?: string): void; /** * Asserts that value's type is not name, as determined by Object.prototype.toString. * * T Type of value. * @param value Actual value. * @param name Potential expected type name of value. * @param message Message to display on error. */ notTypeOf(value: T, name: string, message?: string): void; /** * Asserts that value is an instance of constructor. * * T Expected type of value. * @param value Actual value. * @param constructor Potential expected contructor of value. * @param message Message to display on error. */ instanceOf( value: unknown, constructor: Constructor, message?: string, ): asserts value is T; /** * Asserts that value is not an instance of constructor. * * T Type of value. * U Type that value shouldn't be an instance of. * @param value Actual value. * @param constructor Potential expected contructor of value. * @param message Message to display on error. */ notInstanceOf(value: T, type: Constructor, message?: string): asserts value is Exclude; /** * Asserts that haystack includes needle. * * @param haystack Container string. * @param needle Potential substring of haystack. * @param message Message to display on error. */ include(haystack: string, needle: string, message?: string): void; /** * Asserts that haystack includes needle. * * T Type of values in haystack. * @param haystack Container array, set or map. * @param needle Potential value contained in haystack. * @param message Message to display on error. */ include( haystack: readonly T[] | ReadonlySet | ReadonlyMap, needle: T, message?: string, ): void; /** * Asserts that haystack includes needle. * * T Type of values in haystack. * @param haystack WeakSet container. * @param needle Potential value contained in haystack. * @param message Message to display on error. */ include(haystack: WeakSet, needle: T, message?: string): void; /** * Asserts that haystack includes needle. * * T Type of haystack. * @param haystack Object. * @param needle Potential subset of the haystack's properties. * @param message Message to display on error. */ include(haystack: T, needle: Partial, message?: string): void; /** * Asserts that haystack does not include needle. * * @param haystack Container string. * @param needle Potential substring of haystack. * @param message Message to display on error. */ notInclude(haystack: string, needle: string, message?: string): void; /** * Asserts that haystack does not include needle. * * T Type of values in haystack. * @param haystack Container array, set or map. * @param needle Potential value contained in haystack. * @param message Message to display on error. */ notInclude( haystack: readonly T[] | ReadonlySet | ReadonlyMap, needle: T, message?: string, ): void; /** * Asserts that haystack does not include needle. * * T Type of values in haystack. * @param haystack WeakSet container. * @param needle Potential value contained in haystack. * @param message Message to display on error. */ notInclude(haystack: WeakSet, needle: T, message?: string): void; /** * Asserts that haystack does not include needle. * * T Type of haystack. * @param haystack Object. * @param needle Potential subset of the haystack's properties. * @param message Message to display on error. */ notInclude(haystack: T, needle: Partial, message?: string): void; /** * Asserts that haystack includes needle. Deep equality is used. * * @param haystack Container string. * @param needle Potential substring of haystack. * @param message Message to display on error. * * @deprecated Does not have any effect on string. Use {@link Assert#include} instead. */ deepInclude(haystack: string, needle: string, message?: string): void; /** * Asserts that haystack includes needle. Deep equality is used. * * T Type of values in haystack. * @param haystack Container array, set or map. * @param needle Potential value contained in haystack. * @param message Message to display on error. */ deepInclude( haystack: readonly T[] | ReadonlySet | ReadonlyMap, needle: T, message?: string, ): void; /** * Asserts that haystack includes needle. Deep equality is used. * * T Type of haystack. * @param haystack Object. * @param needle Potential subset of the haystack's properties. * @param message Message to display on error. */ deepInclude(haystack: T, needle: T extends WeakSet ? never : Partial, message?: string): void; /** * Asserts that haystack does not include needle. Deep equality is used. * * @param haystack Container string. * @param needle Potential substring of haystack. * @param message Message to display on error. * * @deprecated Does not have any effect on string. Use {@link Assert#notInclude} instead. */ notDeepInclude(haystack: string, needle: string, message?: string): void; /** * Asserts that haystack does not include needle. Deep equality is used. * * T Type of values in haystack. * @param haystack Container array, set or map. * @param needle Potential value contained in haystack. * @param message Message to display on error. */ notDeepInclude( haystack: readonly T[] | ReadonlySet | ReadonlyMap, needle: T, message?: string, ): void; /** * Asserts that haystack does not include needle. Deep equality is used. * * T Type of haystack. * @param haystack Object. * @param needle Potential subset of the haystack's properties. * @param message Message to display on error. */ notDeepInclude(haystack: T, needle: T extends WeakSet ? never : Partial, message?: string): void; /** * Asserts that ‘haystack’ includes ‘needle’. Can be used to assert the inclusion of a subset of properties in an object. * * Enables the use of dot- and bracket-notation for referencing nested properties. * ‘[]’ and ‘.’ in property names can be escaped using double backslashes.Asserts that ‘haystack’ includes ‘needle’. * Can be used to assert the inclusion of a subset of properties in an object. * Enables the use of dot- and bracket-notation for referencing nested properties. * ‘[]’ and ‘.’ in property names can be escaped using double backslashes. * * @param haystack * @param needle * @param message Message to display on error. */ nestedInclude(haystack: any, needle: any, message?: string): void; /** * Asserts that ‘haystack’ does not include ‘needle’. Can be used to assert the absence of a subset of properties in an object. * * Enables the use of dot- and bracket-notation for referencing nested properties. * ‘[]’ and ‘.’ in property names can be escaped using double backslashes.Asserts that ‘haystack’ includes ‘needle’. * Can be used to assert the inclusion of a subset of properties in an object. * Enables the use of dot- and bracket-notation for referencing nested properties. * ‘[]’ and ‘.’ in property names can be escaped using double backslashes. * * @param haystack * @param needle * @param message Message to display on error. */ notNestedInclude(haystack: any, needle: any, message?: string): void; /** * 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 * * Enables the use of dot- and bracket-notation for referencing nested properties. * ‘[]’ and ‘.’ in property names can be escaped using double backslashes.Asserts that ‘haystack’ includes ‘needle’. * Can be used to assert the inclusion of a subset of properties in an object. * Enables the use of dot- and bracket-notation for referencing nested properties. * ‘[]’ and ‘.’ in property names can be escaped using double backslashes. * * @param haystack * @param needle * @param message Message to display on error. */ deepNestedInclude(haystack: any, needle: any, message?: string): void; /** * 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. * * Enables the use of dot- and bracket-notation for referencing nested properties. * ‘[]’ and ‘.’ in property names can be escaped using double backslashes.Asserts that ‘haystack’ includes ‘needle’. * Can be used to assert the inclusion of a subset of properties in an object. * Enables the use of dot- and bracket-notation for referencing nested properties. * ‘[]’ and ‘.’ in property names can be escaped using double backslashes. * * @param haystack * @param needle * @param message Message to display on error. */ notDeepNestedInclude(haystack: any, needle: any, message?: string): void; /** * Asserts that ‘haystack’ includes ‘needle’. Can be used to assert the inclusion of a subset of properties in an object while ignoring inherited properties. * * @param haystack * @param needle * @param message Message to display on error. */ ownInclude(haystack: any, needle: any, message?: string): void; /** * Asserts that ‘haystack’ includes ‘needle’. Can be used to assert the absence of a subset of properties in an object while ignoring inherited properties. * * @param haystack * @param needle * @param message Message to display on error. */ notOwnInclude(haystack: any, needle: any, message?: string): void; /** * 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 * * @param haystack * @param needle * @param message Message to display on error. */ deepOwnInclude(haystack: any, needle: any, message?: string): void; /** * 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. * * @param haystack * @param needle * @param message Message to display on error. */ notDeepOwnInclude(haystack: any, needle: any, message?: string): void; /** * Asserts that value matches the regular expression regexp. * * @param value Actual value. * @param regexp Potential match of value. * @param message Message to display on error. */ match(value: string, regexp: RegExp, message?: string): void; /** * Asserts that value does not match the regular expression regexp. * * @param value Actual value. * @param regexp Potential match of value. * @param message Message to display on error. */ notMatch(expected: any, regexp: RegExp, message?: string): void; /** * Asserts that object has a property named by property. * * T Type of object. * @param object Container object. * @param property Potential contained property of object. * @param message Message to display on error. */ property(object: T, property: string, /* keyof T */ message?: string): void; /** * Asserts that object does not have a property named by property. * * T Type of object. * @param object Container object. * @param property Potential contained property of object. * @param message Message to display on error. */ notProperty(object: T, property: string, /* keyof T */ message?: string): void; /** * Asserts that object has a property named by property, which can be a string * using dot- and bracket-notation for deep reference. * * T Type of object. * @param object Container object. * @param property Potential contained property of object. * @param message Message to display on error. */ deepProperty(object: T, property: string, message?: string): void; /** * Asserts that object does not have a property named by property, which can be a * string using dot- and bracket-notation for deep reference. * * T Type of object. * @param object Container object. * @param property Potential contained property of object. * @param message Message to display on error. */ notDeepProperty(object: T, property: string, message?: string): void; /** * Asserts that object has a property named by property with value given by value. * * T Type of object. * V Type of value. * @param object Container object. * @param property Potential contained property of object. * @param value Potential expected property value. * @param message Message to display on error. */ propertyVal(object: T, property: string, /* keyof T */ value: V, message?: string): void; /** * Asserts that object has a property named by property with value given by value. * * T Type of object. * V Type of value. * @param object Container object. * @param property Potential contained property of object. * @param value Potential expected property value. * @param message Message to display on error. */ notPropertyVal(object: T, property: string, /* keyof T */ value: V, message?: string): void; /** * Asserts that object has a property named by property, which can be a string * using dot- and bracket-notation for deep reference. * * T Type of object. * V Type of value. * @param object Container object. * @param property Potential contained property of object. * @param value Potential expected property value. * @param message Message to display on error. */ deepPropertyVal(object: T, property: string, value: V, message?: string): void; /** * Asserts that object does not have a property named by property, which can be a * string using dot- and bracket-notation for deep reference. * * T Type of object. * V Type of value. * @param object Container object. * @param property Potential contained property of object. * @param value Potential expected property value. * @param message Message to display on error. */ notDeepPropertyVal(object: T, property: string, value: V, message?: string): void; /** * Asserts that object has a length property with the expected value. * * T Type of object. * @param object Container object. * @param length Potential expected length of object. * @param message Message to display on error. */ lengthOf( object: T, length: number, message?: string, ): void; /** * Asserts that fn will throw an error. * * @param fn Function that may throw. * @param errMsgMatcher Expected error message matcher. * @param ignored Ignored parameter. * @param message Message to display on error. */ throw(fn: () => void, errMsgMatcher?: RegExp | string, ignored?: any, message?: string): void; /** * Asserts that fn will throw an error. * * @param fn Function that may throw. * @param errorLike Expected error constructor or error instance. * @param errMsgMatcher Expected error message matcher. * @param message Message to display on error. */ throw( fn: () => void, errorLike?: ErrorConstructor | Error | null, errMsgMatcher?: RegExp | string | null, message?: string, ): void; /** * Asserts that fn will throw an error. * * @param fn Function that may throw. * @param errMsgMatcher Expected error message matcher. * @param ignored Ignored parameter. * @param message Message to display on error. */ throws(fn: () => void, errMsgMatcher?: RegExp | string, ignored?: any, message?: string): void; /** * Asserts that fn will throw an error. * * @param fn Function that may throw. * @param errorLike Expected error constructor or error instance. * @param errMsgMatcher Expected error message matcher. * @param message Message to display on error. */ throws( fn: () => void, errorLike?: ErrorConstructor | Error | null, errMsgMatcher?: RegExp | string | null, message?: string, ): void; /** * Asserts that fn will throw an error. * * @param fn Function that may throw. * @param errMsgMatcher Expected error message matcher. * @param ignored Ignored parameter. * @param message Message to display on error. */ Throw(fn: () => void, errMsgMatcher?: RegExp | string, ignored?: any, message?: string): void; /** * Asserts that fn will throw an error. * * @param fn Function that may throw. * @param errorLike Expected error constructor or error instance. * @param errMsgMatcher Expected error message matcher. * @param message Message to display on error. */ Throw( fn: () => void, errorLike?: ErrorConstructor | Error | null, errMsgMatcher?: RegExp | string | null, message?: string, ): void; /** * Asserts that fn will not throw an error. * * @param fn Function that may throw. * @param errMsgMatcher Expected error message matcher. * @param ignored Ignored parameter. * @param message Message to display on error. */ doesNotThrow(fn: () => void, errMsgMatcher?: RegExp | string, ignored?: any, message?: string): void; /** * Asserts that fn will not throw an error. * * @param fn Function that may throw. * @param errorLike Expected error constructor or error instance. * @param errMsgMatcher Expected error message matcher. * @param message Message to display on error. */ doesNotThrow( fn: () => void, errorLike?: ErrorConstructor | Error | null, errMsgMatcher?: RegExp | string | null, message?: string, ): void; /** * Compares two values using operator. * * @param val1 Left value during comparison. * @param operator Comparison operator. * @param val2 Right value during comparison. * @param message Message to display on error. */ operator(val1: OperatorComparable, operator: Operator, val2: OperatorComparable, message?: string): void; /** * Asserts that the target is equal to expected, to within a +/- delta range. * * @param actual Actual value * @param expected Potential expected value. * @param delta Maximum differenced between values. * @param message Message to display on error. */ closeTo(actual: number, expected: number, delta: number, message?: string): void; /** * Asserts that the target is equal to expected, to within a +/- delta range. * * @param actual Actual value * @param expected Potential expected value. * @param delta Maximum differenced between values. * @param message Message to display on error. */ approximately(act: number, exp: number, delta: number, message?: string): void; /** * Asserts that set1 and set2 have the same members. Order is not take into account. * * T Type of set values. * @param set1 Actual set of values. * @param set2 Potential expected set of values. * @param message Message to display on error. */ sameMembers(set1: T[], set2: T[], message?: string): void; /** * Asserts that set1 and set2 have the same members using deep equality checking. * Order is not take into account. * * T Type of set values. * @param set1 Actual set of values. * @param set2 Potential expected set of values. * @param message Message to display on error. */ sameDeepMembers(set1: T[], set2: T[], message?: string): void; /** * Asserts that `set1` and `set2` don't have the same members in any order. * Uses a deep equality check. * * T Type of set values. * @param set1 * @param set2 * @param message */ notSameDeepMembers(set1: T[], set2: T[], message?: string): void; /** * Asserts that set1 and set2 have the same members in the same order. * Uses a strict equality check (===). * * T Type of set values. * @param set1 Actual set of values. * @param set2 Potential expected set of values. * @param message Message to display on error. */ sameOrderedMembers(set1: T[], set2: T[], message?: string): void; /** * Asserts that set1 and set2 don’t have the same members in the same order. * Uses a strict equality check (===). * * T Type of set values. * @param set1 Actual set of values. * @param set2 Potential expected set of values. * @param message Message to display on error. */ notSameOrderedMembers(set1: T[], set2: T[], message?: string): void; /** * Asserts that set1 and set2 have the same members in the same order. * Uses a deep equality check. * * T Type of set values. * @param set1 Actual set of values. * @param set2 Potential expected set of values. * @param message Message to display on error. */ sameDeepOrderedMembers(set1: T[], set2: T[], message?: string): void; /** * Asserts that set1 and set2 don’t have the same members in the same order. * Uses a deep equality check. * * T Type of set values. * @param set1 Actual set of values. * @param set2 Potential expected set of values. * @param message Message to display on error. */ notSameDeepOrderedMembers(set1: T[], set2: T[], message?: string): void; /** * Asserts that subset is included in superset in the same order beginning with the first element in superset. * Uses a strict equality check (===). * * T Type of set values. * @param superset Actual set of values. * @param subset Potential contained set of values. * @param message Message to display on error. */ includeOrderedMembers(superset: T[], subset: T[], message?: string): void; /** * Asserts that subset isn’t included in superset in the same order beginning with the first element in superset. * Uses a strict equality check (===). * * T Type of set values. * @param superset Actual set of values. * @param subset Potential contained set of values. * @param message Message to display on error. */ notIncludeOrderedMembers(superset: T[], subset: T[], message?: string): void; /** * Asserts that subset is included in superset in the same order beginning with the first element in superset. * Uses a deep equality check. * * T Type of set values. * @param superset Actual set of values. * @param subset Potential contained set of values. * @param message Message to display on error. */ includeDeepOrderedMembers(superset: T[], subset: T[], message?: string): void; /** * Asserts that subset isn’t included in superset in the same order beginning with the first element in superset. * Uses a deep equality check. * * T Type of set values. * @param superset Actual set of values. * @param subset Potential contained set of values. * @param message Message to display on error. */ notIncludeDeepOrderedMembers(superset: T[], subset: T[], message?: string): void; /** * Asserts that subset is included in superset. Order is not take into account. * * T Type of set values. * @param superset Actual set of values. * @param subset Potential contained set of values. * @param message Message to display on error. */ includeMembers(superset: T[], subset: T[], message?: string): void; /** * Asserts that subset isn’t included in superset in any order. * Uses a strict equality check (===). Duplicates are ignored. * * T Type of set values. * @param superset Actual set of values. * @param subset Potential not contained set of values. * @param message Message to display on error. */ notIncludeMembers(superset: T[], subset: T[], message?: string): void; /** * Asserts that subset is included in superset using deep equality checking. * Order is not take into account. * * T Type of set values. * @param superset Actual set of values. * @param subset Potential contained set of values. * @param message Message to display on error. */ includeDeepMembers(superset: T[], subset: T[], message?: string): void; /** * Asserts that `subset` isn't included in `superset` in any order. Uses a * deep equality check. Duplicates are ignored. * * assert.notIncludeDeepMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { b: 2 }, { f: 5 } ], 'not include deep members'); * * T Type of set values. * @param superset Actual set of values. * @param subset Potential contained set of values. * @param message Message to display on error. */ notIncludeDeepMembers(superset: T[], subset: T[], message?: string): void; /** * Asserts that non-object, non-array value inList appears in the flat array list. * * T Type of list values. * @param inList Value expected to be in the list. * @param list List of values. * @param message Message to display on error. */ oneOf(inList: T, list: T[], message?: string): void; /** * Asserts that a function changes the value of a property. * * T Type of object. * @param modifier Function to run. * @param object Container object. * @param property Property of object expected to be modified. * @param message Message to display on error. */ changes(modifier: Function, object: T, property: string, /* keyof T */ message?: string): void; /** * Asserts that a function changes the value of a property by an amount (delta). * * @param modifier function * @param object or getter function * @param property name _optional_ * @param change amount (delta) * @param message _optional_ */ changesBy( modifier: Function, object: T, property: string, /* keyof T */ change: number, message?: string, ): void; changesBy(modifier: Function, object: T, change: number, message?: string): void; /** * Asserts that a function does not change the value of a property. * * T Type of object. * @param modifier Function to run. * @param object Container object. * @param property Property of object expected not to be modified. * @param message Message to display on error. */ doesNotChange(modifier: Function, object: T, property: string, /* keyof T */ message?: string): void; /** * Asserts that a function increases an object property. * * T Type of object. * @param modifier Function to run. * @param object Container object. * @param property Property of object expected to be increased. * @param message Message to display on error. */ increases(modifier: Function, object: T, property: string, /* keyof T */ message?: string): void; /** * Asserts that a function increases a numeric object property or a function's return value by an amount (delta). * * T Type of object or function. * @param modifier function * @param object or getter function * @param property name _optional_ * @param change amount (delta) * @param message _optional_ */ increasesBy( modifier: Function, object: T, property: string, /* keyof T */ change: number, message?: string, ): void; increasesBy(modifier: Function, object: T, change: number, message?: string): void; /** * Asserts that a function does not increase an object property. * * T Type of object. * @param modifier Function to run. * @param object Container object. * @param property Property of object expected not to be increased. * @param message Message to display on error. */ doesNotIncrease(modifier: Function, object: T, property: string, /* keyof T */ message?: string): void; /** * Asserts that a function does not increase a numeric object property or function's return value by an amount (delta). * * T Type of object or function. * @param modifier function * @param object or getter function * @param property name _optional_ * @param change amount (delta) * @param message _optional_ */ increasesButNotBy( modifier: Function, object: T, property: string, /* keyof T */ change: number, message?: string, ): void; increasesButNotBy(modifier: Function, object: T, change: number, message?: string): void; /** * Asserts that a function decreases an object property. * * T Type of object. * @param modifier Function to run. * @param object Container object. * @param property Property of object expected to be decreased. * @param message Message to display on error. */ decreases(modifier: Function, object: T, property: string, /* keyof T */ message?: string): void; /** * Asserts that a function decreases a numeric object property or a function's return value by an amount (delta) * * T Type of object or function. * @param modifier function * @param object or getter function * @param property name _optional_ * @param change amount (delta) * @param message _optional_ */ decreasesBy( modifier: Function, object: T, property: string, /* keyof T */ change: number, message?: string, ): void; decreasesBy(modifier: Function, object: T, change: number, message?: string): void; /** * Asserts that a function does not decrease an object property. * * T Type of object. * @param modifier Function to run. * @param object Container object. * @param property Property of object expected not to be decreased. * @param message Message to display on error. */ doesNotDecrease(modifier: Function, object: T, property: string, /* keyof T */ message?: string): void; /** * Asserts that a function does not decreases a numeric object property or a function's return value by an amount (delta) * * T Type of object or function. * @param modifier function * @param object or getter function * @param property name _optional_ * @param change amount (delta) * @param message _optional_ */ doesNotDecreaseBy( modifier: Function, object: T, property: string, /* keyof T */ change: number, message?: string, ): void; doesNotDecreaseBy(modifier: Function, object: T, change: number, message?: string): void; /** * Asserts that a function does not decreases a numeric object property or a function's return value by an amount (delta) * * T Type of object or function. * @param modifier function * @param object or getter function * @param property name _optional_ * @param change amount (delta) * @param message _optional_ */ decreasesButNotBy( modifier: Function, object: T, property: string, /* keyof T */ change: number, message?: string, ): void; decreasesButNotBy(modifier: Function, object: T, change: number, message?: string): void; /** * Asserts if value is not a false value, and throws if it is a true value. * * T Type of object. * @param object Actual value. * @param message Message to display on error. * @remarks This is added to allow for chai to be a drop-in replacement for * Node’s assert class. */ ifError(object: T, message?: string): void; /** * Asserts that object is extensible (can have new properties added to it). * * T Type of object * @param object Actual value. * @param message Message to display on error. */ isExtensible(object: T, message?: string): void; /** * Asserts that object is extensible (can have new properties added to it). * * T Type of object * @param object Actual value. * @param message Message to display on error. */ extensible(object: T, message?: string): void; /** * Asserts that object is not extensible. * * T Type of object * @param object Actual value. * @param message Message to display on error. */ isNotExtensible(object: T, message?: string): void; /** * Asserts that object is not extensible. * * T Type of object * @param object Actual value. * @param message Message to display on error. */ notExtensible(object: T, message?: string): void; /** * Asserts that object is sealed (can have new properties added to it * and its existing properties cannot be removed). * * T Type of object * @param object Actual value. * @param message Message to display on error. */ isSealed(object: T, message?: string): void; /** * Asserts that object is sealed (can have new properties added to it * and its existing properties cannot be removed). * * T Type of object * @param object Actual value. * @param message Message to display on error. */ sealed(object: T, message?: string): void; /** * Asserts that object is not sealed. * * T Type of object * @param object Actual value. * @param message Message to display on error. */ isNotSealed(object: T, message?: string): void; /** * Asserts that object is not sealed. * * T Type of object * @param object Actual value. * @param message Message to display on error. */ notSealed(object: T, message?: string): void; /** * Asserts that object is frozen (cannot have new properties added to it * and its existing properties cannot be removed). * * T Type of object * @param object Actual value. * @param message Message to display on error. */ isFrozen(object: T, message?: string): void; /** * Asserts that object is frozen (cannot have new properties added to it * and its existing properties cannot be removed). * * T Type of object * @param object Actual value. * @param message Message to display on error. */ frozen(object: T, message?: string): void; /** * Asserts that object is not frozen (cannot have new properties added to it * and its existing properties cannot be removed). * * T Type of object * @param object Actual value. * @param message Message to display on error. */ isNotFrozen(object: T, message?: string): void; /** * Asserts that object is not frozen (cannot have new properties added to it * and its existing properties cannot be removed). * * T Type of object * @param object Actual value. * @param message Message to display on error. */ notFrozen(object: T, message?: string): void; /** * Asserts that the target does not contain any values. For arrays and * strings, it checks the length property. For Map and Set instances, it * checks the size property. For non-function objects, it gets the count * of own enumerable string keys. * * T Type of object * @param object Actual value. * @param message Message to display on error. */ isEmpty(object: T, message?: string): void; /** * Asserts that the target contains values. For arrays and strings, it checks * the length property. For Map and Set instances, it checks the size property. * For non-function objects, it gets the count of own enumerable string keys. * * T Type of object. * @param object Object to test. * @param message Message to display on error. */ isNotEmpty(object: T, message?: string): void; /** * Asserts that `object` has at least one of the `keys` provided. * You can also provide a single object instead of a `keys` array and its keys * will be used as the expected set of keys. * * T Type of object. * @param object Object to test. * @param keys Keys to check * @param message Message to display on error. */ hasAnyKeys(object: T, keys: Array | { [key: string]: any }, message?: string): void; /** * Asserts that `object` has all and only all of the `keys` provided. * You can also provide a single object instead of a `keys` array and its keys * will be used as the expected set of keys. * * T Type of object. * @param object Object to test. * @param keys Keys to check * @param message Message to display on error. */ hasAllKeys(object: T, keys: Array | { [key: string]: any }, message?: string): void; /** * Asserts that `object` has all of the `keys` provided but may have more keys not listed. * You can also provide a single object instead of a `keys` array and its keys * will be used as the expected set of keys. * * T Type of object. * @param object Object to test. * @param keys Keys to check * @param message Message to display on error. */ containsAllKeys( object: T, keys: Array | { [key: string]: any }, message?: string, ): void; /** * Asserts that `object` has none of the `keys` provided. * You can also provide a single object instead of a `keys` array and its keys * will be used as the expected set of keys. * * T Type of object. * @param object Object to test. * @param keys Keys to check * @param message Message to display on error. */ doesNotHaveAnyKeys( object: T, keys: Array | { [key: string]: any }, message?: string, ): void; /** * Asserts that `object` does not have at least one of the `keys` provided. * You can also provide a single object instead of a `keys` array and its keys * will be used as the expected set of keys. * * T Type of object. * @param object Object to test. * @param keys Keys to check * @param message Message to display on error. */ doesNotHaveAllKeys( object: T, keys: Array | { [key: string]: any }, message?: string, ): void; /** * Asserts that `object` has at least one of the `keys` provided. * Since Sets and Maps can have objects as keys you can use this assertion to perform * a deep comparison. * You can also provide a single object instead of a `keys` array and its keys * will be used as the expected set of keys. * * T Type of object. * @param object Object to test. * @param keys Keys to check * @param message Message to display on error. */ hasAnyDeepKeys(object: T, keys: Array | { [key: string]: any }, message?: string): void; /** * Asserts that `object` has all and only all of the `keys` provided. * Since Sets and Maps can have objects as keys you can use this assertion to perform * a deep comparison. * You can also provide a single object instead of a `keys` array and its keys * will be used as the expected set of keys. * * T Type of object. * @param object Object to test. * @param keys Keys to check * @param message Message to display on error. */ hasAllDeepKeys(object: T, keys: Array | { [key: string]: any }, message?: string): void; /** * Asserts that `object` contains all of the `keys` provided. * Since Sets and Maps can have objects as keys you can use this assertion to perform * a deep comparison. * You can also provide a single object instead of a `keys` array and its keys * will be used as the expected set of keys. * * T Type of object. * @param object Object to test. * @param keys Keys to check * @param message Message to display on error. */ containsAllDeepKeys( object: T, keys: Array | { [key: string]: any }, message?: string, ): void; /** * Asserts that `object` contains all of the `keys` provided. * Since Sets and Maps can have objects as keys you can use this assertion to perform * a deep comparison. * You can also provide a single object instead of a `keys` array and its keys * will be used as the expected set of keys. * * T Type of object. * @param object Object to test. * @param keys Keys to check * @param message Message to display on error. */ doesNotHaveAnyDeepKeys( object: T, keys: Array | { [key: string]: any }, message?: string, ): void; /** * Asserts that `object` contains all of the `keys` provided. * Since Sets and Maps can have objects as keys you can use this assertion to perform * a deep comparison. * You can also provide a single object instead of a `keys` array and its keys * will be used as the expected set of keys. * * T Type of object. * @param object Object to test. * @param keys Keys to check * @param message Message to display on error. */ doesNotHaveAllDeepKeys( object: T, keys: Array | { [key: string]: any }, message?: string, ): void; /** * Asserts that object has a direct or inherited property named by property, * which can be a string using dot- and bracket-notation for nested reference. * * T Type of object. * @param object Object to test. * @param property Property to test. * @param message Message to display on error. */ nestedProperty(object: T, property: string, message?: string): void; /** * Asserts that object does not have a property named by property, * which can be a string using dot- and bracket-notation for nested reference. * The property cannot exist on the object nor anywhere in its prototype chain. * * T Type of object. * @param object Object to test. * @param property Property to test. * @param message Message to display on error. */ notNestedProperty(object: T, property: string, message?: string): void; /** * Asserts that object has a property named by property with value given by value. * property can use dot- and bracket-notation for nested reference. Uses a strict equality check (===). * * T Type of object. * @param object Object to test. * @param property Property to test. * @param value Value to test. * @param message Message to display on error. */ nestedPropertyVal(object: T, property: string, value: any, message?: string): void; /** * Asserts that object does not have a property named by property with value given by value. * property can use dot- and bracket-notation for nested reference. Uses a strict equality check (===). * * T Type of object. * @param object Object to test. * @param property Property to test. * @param value Value to test. * @param message Message to display on error. */ notNestedPropertyVal(object: T, property: string, value: any, message?: string): void; /** * Asserts that object has a property named by property with a value given by value. * property can use dot- and bracket-notation for nested reference. Uses a deep equality check. * * T Type of object. * @param object Object to test. * @param property Property to test. * @param value Value to test. * @param message Message to display on error. */ deepNestedPropertyVal(object: T, property: string, value: any, message?: string): void; /** * Asserts that object does not have a property named by property with value given by value. * property can use dot- and bracket-notation for nested reference. Uses a deep equality check. * * T Type of object. * @param object Object to test. * @param property Property to test. * @param value Value to test. * @param message Message to display on error. */ notDeepNestedPropertyVal(object: T, property: string, value: any, message?: string): void; } export interface Config { /** * Default: false */ includeStack: boolean; /** * Default: true */ showDiff: boolean; /** * Default: 40 */ truncateThreshold: number; /** * Default: true */ useProxy: boolean; /** * Default: ['then', 'catch', 'inspect', 'toJSON'] */ proxyExcludedKeys: string[]; deepEqual: (expected: L, actual: R) => void; } export class AssertionError { constructor(message: string, _props?: any, ssf?: Function); name: string; message: string; showDiff: boolean; stack: string; } } } export function use(fn: Chai.ChaiPlugin): Chai.ChaiStatic; export const util: Chai.ChaiUtils; export const config: Chai.Config; export const Assertion: Chai.AssertionStatic; export function should(): Chai.Should; export function Should(): Chai.Should; export const assert: Chai.AssertStatic; export const expect: Chai.ExpectStatic; chai/package.json000644 001751 000166 0000004307 15006227306015731 0ustar00runner000000 000000 1500622731615006227306{ "name": "@types/chai", "version": "5.2.2", "description": "TypeScript definitions for chai", "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/chai", "license": "MIT", "contributors": [ { "name": "Bart van der Schoor", "githubUsername": "Bartvds", "url": "https://github.com/Bartvds" }, { "name": "Andrew Brown", "githubUsername": "AGBrown", "url": "https://github.com/AGBrown" }, { "name": "Olivier Chevet", "githubUsername": "olivr70", "url": "https://github.com/olivr70" }, { "name": "Matt Wistrand", "githubUsername": "mwistrand", "url": "https://github.com/mwistrand" }, { "name": "Shaun Luttin", "githubUsername": "shaunluttin", "url": "https://github.com/shaunluttin" }, { "name": "Satana Charuwichitratana", "githubUsername": "micksatana", "url": "https://github.com/micksatana" }, { "name": "Erik Schierboom", "githubUsername": "ErikSchierboom", "url": "https://github.com/ErikSchierboom" }, { "name": "Bogdan Paranytsia", "githubUsername": "bparan", "url": "https://github.com/bparan" }, { "name": "CXuesong", "githubUsername": "CXuesong", "url": "https://github.com/CXuesong" }, { "name": "Joey Kilpatrick", "githubUsername": "joeykilpatrick", "url": "https://github.com/joeykilpatrick" } ], "type": "module", "main": "", "types": "index.d.ts", "repository": { "type": "git", "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git", "directory": "types/chai" }, "scripts": {}, "dependencies": { "@types/deep-eql": "*" }, "peerDependencies": {}, "typesPublisherContentHash": "174d4205d8ad5de1f59dc1f4c1ca29f9ec7d12d905cd5eb02cd537b1e90e8a74", "typeScriptVersion": "5.1" }chai/register-should.d.ts000644 001751 000166 0000000134 15006227306017346 0ustar00runner000000 000000 1500622730615006227306declare global { interface Object { should: Chai.Assertion; } } export {};