/**

* The `assert` module provides a set of assertion functions for verifying

* invariants.

* @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/assert.js)

*/

declare module 'assert' {

/**

* An alias of {@link ok}.

* @since v0.5.9

* @param value The input that is checked for being truthy.

*/

function assert(value: unknown, message?: string | Error): asserts value;

namespace assert {

/**

* Indicates the failure of an assertion. All errors thrown by the `assert` module

* will be instances of the `AssertionError` class.

*/

class AssertionError extends Error {

actual: unknown;

expected: unknown;

operator: string;

generatedMessage: boolean;

code: 'ERR_ASSERTION';

constructor(options?: {

/** If provided, the error message is set to this value. */

message?: string | undefined;

/** The `actual` property on the error instance. */

actual?: unknown | undefined;

/** The `expected` property on the error instance. */

expected?: unknown | undefined;

/** The `operator` property on the error instance. */

operator?: string | undefined;

/** If provided, the generated stack trace omits frames before this function. */

// tslint:disable-next-line:ban-types

stackStartFn?: Function | undefined;

});

}

/**

* This feature is currently experimental and behavior might still change.

* @since v14.2.0, v12.19.0

* @experimental

*/

class CallTracker {

/**

* The wrapper function is expected to be called exactly `exact` times. If the

* function has not been called exactly `exact` times when `tracker.verify()` is called, then `tracker.verify()` will throw an

* error.

*

* ```js

* import assert from 'assert';

*

* // Creates call tracker.

* const tracker = new assert.CallTracker();

*

* function func() {}

*

* // Returns a function that wraps func() that must be called exact times

* // before tracker.verify().

* const callsfunc = tracker.calls(func);

* ```

* @since v14.2.0, v12.19.0

* @param [fn='A no-op function']

* @param [exact=1]

* @return that wraps `fn`.

*/

calls(exact?: number): () => void;

calls<Func extends (...args: any[]) => any>(fn?: Func, exact?: number): Func;

/**

* The arrays contains information about the expected and actual number of calls of

* the functions that have not been called the expected number of times.

*

* ```js

* import assert from 'assert';

*

* // Creates call tracker.

* const tracker = new assert.CallTracker();

*

* function func() {}

*

* function foo() {}

*

* // Returns a function that wraps func() that must be called exact times

* // before tracker.verify().

* const callsfunc = tracker.calls(func, 2);

*

* // Returns an array containing information on callsfunc()

* tracker.report();

* // [

* // {

* // message: 'Expected the func function to be executed 2 time(s) but was

* // executed 0 time(s).',

* // actual: 0,

* // expected: 2,

* // operator: 'func',

* // stack: stack trace

* // }

* // ]

* ```

* @since v14.2.0, v12.19.0

* @return of objects containing information about the wrapper functions returned by `calls`.

*/

report(): CallTrackerReportInformation[];

/**

* Iterates through the list of functions passed to `tracker.calls()` and will throw an error for functions that

* have not been called the expected number of times.

*

* ```js

* import assert from 'assert';

*

* // Creates call tracker.

* const tracker = new assert.CallTracker();

*

* function func() {}

*

* // Returns a function that wraps func() that must be called exact times

* // before tracker.verify().

* const callsfunc = tracker.calls(func, 2);

*

* callsfunc();

*

* // Will throw an error since callsfunc() was only called once.

* tracker.verify();

* ```

* @since v14.2.0, v12.19.0

*/

verify(): void;

}

interface CallTrackerReportInformation {

message: string;

/** The actual number of times the function was called. */

actual: number;

/** The number of times the function was expected to be called. */

expected: number;

/** The name of the function that is wrapped. */

operator: string;

/** A stack trace of the function. */

stack: object;

}

type AssertPredicate = RegExp | (new () => object) | ((thrown: unknown) => boolean) | object | Error;

/**

* Throws an `AssertionError` with the provided error message or a default

* error message. If the `message` parameter is an instance of an `Error` then

* it will be thrown instead of the `AssertionError`.

*

* ```js

* import assert from 'assert/strict';

*

* assert.fail();

* // AssertionError [ERR_ASSERTION]: Failed

*

* assert.fail('boom');

* // AssertionError [ERR_ASSERTION]: boom

*

* assert.fail(new TypeError('need array'));

* // TypeError: need array

* ```

*

* Using `assert.fail()` with more than two arguments is possible but deprecated.

* See below for further details.

* @since v0.1.21

* @param [message='Failed']

*/

function fail(message?: string | Error): never;

/** @deprecated since v10.0.0 - use fail([message]) or other assert functions instead. */

function fail(

actual: unknown,

expected: unknown,

message?: string | Error,

operator?: string,

// tslint:disable-next-line:ban-types

stackStartFn?: Function

): never;

/**

* Tests if `value` is truthy. It is equivalent to`assert.equal(!!value, true, message)`.

*

* If `value` is not truthy, an `AssertionError` is thrown with a `message`property set equal to the value of the `message` parameter. If the `message`parameter is `undefined`, a default

* error message is assigned. If the `message`parameter is an instance of an `Error` then it will be thrown instead of the`AssertionError`.

* If no arguments are passed in at all `message` will be set to the string:`` 'No value argument passed to `assert.ok()`' ``.

*

* Be aware that in the `repl` the error message will be different to the one

* thrown in a file! See below for further details.

*

* ```js

* import assert from 'assert/strict';

*

* assert.ok(true);

* // OK

* assert.ok(1);

* // OK

*

* assert.ok();

* // AssertionError: No value argument passed to `assert.ok()`

*

* assert.ok(false, 'it\'s false');

* // AssertionError: it's false

*

* // In the repl:

* assert.ok(typeof 123 === 'string');

* // AssertionError: false == true

*

* // In a file (e.g. test.js):

* assert.ok(typeof 123 === 'string');

* // AssertionError: The expression evaluated to a falsy value:

* //

* // assert.ok(typeof 123 === 'string')

*

* assert.ok(false);

* // AssertionError: The expression evaluated to a falsy value:

* //

* // assert.ok(false)

*

* assert.ok(0);

* // AssertionError: The expression evaluated to a falsy value:

* //

* // assert.ok(0)

* ```

*

* ```js

* import assert from 'assert/strict';

*

* // Using `assert()` works the same:

* assert(0);

* // AssertionError: The expression evaluated to a falsy value:

* //

* // assert(0)

* ```

* @since v0.1.21

*/

function ok(value: unknown, message?: string | Error): asserts value;

/**

* **Strict assertion mode**

*

* An alias of {@link strictEqual}.

*

* **Legacy assertion mode**

*

* > Stability: 3 - Legacy: Use {@link strictEqual} instead.

*

* Tests shallow, coercive equality between the `actual` and `expected` parameters

* using the [Abstract Equality Comparison](https://tc39.github.io/ecma262/#sec-abstract-equality-comparison) ( `==` ). `NaN` is special handled

* and treated as being identical in case both sides are `NaN`.

*

* ```js

* import assert from 'assert';

*

* assert.equal(1, 1);

* // OK, 1 == 1

* assert.equal(1, '1');

* // OK, 1 == '1'

* assert.equal(NaN, NaN);

* // OK

*

* assert.equal(1, 2);

* // AssertionError: 1 == 2

* assert.equal({ a: { b: 1 } }, { a: { b: 1 } });

* // AssertionError: { a: { b: 1 } } == { a: { b: 1 } }

* ```

*

* If the values are not equal, an `AssertionError` is thrown with a `message`property set equal to the value of the `message` parameter. If the `message`parameter is undefined, a default

* error message is assigned. If the `message`parameter is an instance of an `Error` then it will be thrown instead of the`AssertionError`.

* @since v0.1.21

*/

function equal(actual: unknown, expected: unknown, message?: string | Error): void;

/**

* **Strict assertion mode**

*

* An alias of {@link notStrictEqual}.

*

* **Legacy assertion mode**

*

* > Stability: 3 - Legacy: Use {@link notStrictEqual} instead.

*

* Tests shallow, coercive inequality with the [Abstract Equality Comparison](https://tc39.github.io/ecma262/#sec-abstract-equality-comparison)(`!=` ). `NaN` is special handled and treated as

* being identical in case both

* sides are `NaN`.

*

* ```js

* import assert from 'assert';

*

* assert.notEqual(1, 2);

* // OK

*

* assert.notEqual(1, 1);

* // AssertionError: 1 != 1

*

* assert.notEqual(1, '1');

* // AssertionError: 1 != '1'

* ```

*

* If the values are equal, an `AssertionError` is thrown with a `message`property set equal to the value of the `message` parameter. If the `message`parameter is undefined, a default error

* message is assigned. If the `message`parameter is an instance of an `Error` then it will be thrown instead of the`AssertionError`.

* @since v0.1.21

*/

function notEqual(actual: unknown, expected: unknown, message?: string | Error): void;

/**

* **Strict assertion mode**

*

* An alias of {@link deepStrictEqual}.

*

* **Legacy assertion mode**

*

* > Stability: 3 - Legacy: Use {@link deepStrictEqual} instead.

*

* Tests for deep equality between the `actual` and `expected` parameters. Consider

* using {@link deepStrictEqual} instead. {@link deepEqual} can have

* surprising results.

*

* _Deep equality_ means that the enumerable "own" properties of child objects

* are also recursively evaluated by the following rules.

* @since v0.1.21

*/

function deepEqual(actual: unknown, expected: unknown, message?: string | Error): void;

/**

* **Strict assertion mode**

*

* An alias of {@link notDeepStrictEqual}.

*

* **Legacy assertion mode**

*

* > Stability: 3 - Legacy: Use {@link notDeepStrictEqual} instead.

*

* Tests for any deep inequality. Opposite of {@link deepEqual}.

*

* ```js

* import assert from 'assert';

*

* const obj1 = {

* a: {

* b: 1

* }

* };

* const obj2 = {

* a: {

* b: 2

* }

* };

* const obj3 = {

* a: {

* b: 1

* }

* };

* const obj4 = Object.create(obj1);

*

* assert.notDeepEqual(obj1, obj1);

* // AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }

*

* assert.notDeepEqual(obj1, obj2);

* // OK

*

* assert.notDeepEqual(obj1, obj3);

* // AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }

*

* assert.notDeepEqual(obj1, obj4);

* // OK

* ```

*

* If the values are deeply equal, an `AssertionError` is thrown with a`message` property set equal to the value of the `message` parameter. If the`message` parameter is undefined, a default

* error message is assigned. If the`message` parameter is an instance of an `Error` then it will be thrown

* instead of the `AssertionError`.

* @since v0.1.21

*/

function notDeepEqual(actual: unknown, expected: unknown, message?: string | Error): void;

/**

* Tests strict equality between the `actual` and `expected` parameters as

* determined by the [SameValue Comparison](https://tc39.github.io/ecma262/#sec-samevalue).

*

* ```js

* import assert from 'assert/strict';

*

* assert.strictEqual(1, 2);

* // AssertionError [ERR_ASSERTION]: Expected inputs to be strictly equal:

* //

* // 1 !== 2

*

* assert.strictEqual(1, 1);

* // OK

*

* assert.strictEqual('Hello foobar', 'Hello World!');

* // AssertionError [ERR_ASSERTION]: Expected inputs to be strictly equal:

* // + actual - expected

* //

* // + 'Hello foobar'

* // - 'Hello World!'

* // ^

*

* const apples = 1;

* const oranges = 2;

* assert.strictEqual(apples, oranges, `apples ${apples} !== oranges ${oranges}`);

* // AssertionError [ERR_ASSERTION]: apples 1 !== oranges 2

*

* assert.strictEqual(1, '1', new TypeError('Inputs are not identical'));

* // TypeError: Inputs are not identical

* ```

*

* If the values are not strictly equal, an `AssertionError` is thrown with a`message` property set equal to the value of the `message` parameter. If the`message` parameter is undefined, a

* default error message is assigned. If the`message` parameter is an instance of an `Error` then it will be thrown

* instead of the `AssertionError`.

* @since v0.1.21

*/

function strictEqual<T>(actual: unknown, expected: T, message?: string | Error): asserts actual is T;

/**

* Tests strict inequality between the `actual` and `expected` parameters as

* determined by the [SameValue Comparison](https://tc39.github.io/ecma262/#sec-samevalue).

*

* ```js

* import assert from 'assert/strict';

*

* assert.notStrictEqual(1, 2);

* // OK

*

* assert.notStrictEqual(1, 1);

* // AssertionError [ERR_ASSERTION]: Expected "actual" to be strictly unequal to:

* //

* // 1

*

* assert.notStrictEqual(1, '1');

* // OK

* ```

*

* If the values are strictly equal, an `AssertionError` is thrown with a`message` property set equal to the value of the `message` parameter. If the`message` parameter is undefined, a

* default error message is assigned. If the`message` parameter is an instance of an `Error` then it will be thrown

* instead of the `AssertionError`.

* @since v0.1.21

*/

function notStrictEqual(actual: unknown, expected: unknown, message?: string | Error): void;

/**

* Tests for deep equality between the `actual` and `expected` parameters.

* "Deep" equality means that the enumerable "own" properties of child objects

* are recursively evaluated also by the following rules.

* @since v1.2.0

*/

function deepStrictEqual<T>(actual: unknown, expected: T, message?: string | Error): asserts actual is T;

/**

* Tests for deep strict inequality. Opposite of {@link deepStrictEqual}.

*

* ```js

* import assert from 'assert/strict';

*

* assert.notDeepStrictEqual({ a: 1 }, { a: '1' });

* // OK

* ```

*

* If the values are deeply and strictly equal, an `AssertionError` is thrown

* with a `message` property set equal to the value of the `message` parameter. If

* the `message` parameter is undefined, a default error message is assigned. If

* the `message` parameter is an instance of an `Error` then it will be thrown

* instead of the `AssertionError`.

* @since v1.2.0

*/

function notDeepStrictEqual(actual: unknown, expected: unknown, message?: string | Error): void;

/**

* Expects the function `fn` to throw an error.

*

* If specified, `error` can be a [`Class`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes),

* [`RegExp`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions), a validation function,

* a validation object where each property will be tested for strict deep equality,

* or an instance of error where each property will be tested for strict deep

* equality including the non-enumerable `message` and `name` properties. When

* using an object, it is also possible to use a regular expression, when

* validating against a string property. See below for examples.

*

* If specified, `message` will be appended to the message provided by the`AssertionError` if the `fn` call fails to throw or in case the error validation

* fails.

*

* Custom validation object/error instance:

*

* ```js

* import assert from 'assert/strict';

*

* const err = new TypeError('Wrong value');

* err.code = 404;

* err.foo = 'bar';

* err.info = {

* nested: true,

* baz: 'text'

* };

* err.reg = /abc/i;

*

* assert.throws(

* () => {

* throw err;

* },

* {

* name: 'TypeError',

* message: 'Wrong value',

* info: {

* nested: true,

* baz: 'text'

* }

* // Only properties on the validation object will be tested for.

* // Using nested objects requires all properties to be present. Otherwise

* // the validation is going to fail.

* }

* );

*

* // Using regular expressions to validate error properties:

* throws(

* () => {

* throw err;

* },

* {

* // The `name` and `message` properties are strings and using regular

* // expressions on those will match against the string. If they fail, an

* // error is thrown.

* name: /^TypeError$/,

* message: /Wrong/,

* foo: 'bar',

* info: {

* nested: true,

* // It is not possible to use regular expressions for nested properties!

* baz: 'text'

* },

* // The `reg` property contains a regular expression and only if the

* // validation object contains an identical regular expression, it is going

* // to pass.

* reg: /abc/i

* }

* );

*

* // Fails due to the different `message` and `name` properties:

* throws(

* () => {

* const otherErr = new Error('Not found');

* // Copy all enumerable properties from `err` to `otherErr`.

* for (const [key, value] of Object.entries(err)) {

* otherErr[key] = value;

* }

* throw otherErr;

* },

* // The error's `message` and `name` properties will also be checked when using

* // an error as validation object.

* err

* );

* ```

*

* Validate instanceof using constructor:

*

* ```js

* import assert from 'assert/strict';

*

* assert.throws(

* () => {

* throw new Error('Wrong value');

* },

* Error

* );

* ```

*

* Validate error message using [`RegExp`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions):

*

* Using a regular expression runs `.toString` on the error object, and will

* therefore also include the error name.

*

* ```js

* import assert from 'assert/strict';

*

* assert.throws(

* () => {

* throw new Error('Wrong value');

* },

* /^Error: Wrong value$/

* );

* ```

*

* Custom error validation:

*

* The function must return `true` to indicate all internal validations passed.

* It will otherwise fail with an `AssertionError`.

*

* ```js

* import assert from 'assert/strict';

*

* assert.throws(

* () => {

* throw new Error('Wrong value');

* },

* (err) => {

* assert(err instanceof Error);

* assert(/value/.test(err));

* // Avoid returning anything from validation functions besides `true`.

* // Otherwise, it's not clear what part of the validation failed. Instead,

* // throw an error about the specific validation that failed (as done in this

* // example) and add as much helpful debugging information to that error as

* // possible.

* return true;

* },

* 'unexpected error'

* );

* ```

*

* `error` cannot be a string. If a string is provided as the second

* argument, then `error` is assumed to be omitted and the string will be used for`message` instead. This can lead to easy-to-miss mistakes. Using the same

* message as the thrown error message is going to result in an`ERR_AMBIGUOUS_ARGUMENT` error. Please read the example below carefully if using

* a string as the second argument gets considered:

*

* ```js

* import assert from 'assert/strict';

*

* function throwingFirst() {

* throw new Error('First');

* }

*

* function throwingSecond() {

* throw new Error('Second');

* }

*

* function notThrowing() {}

*

* // The second argument is a string and the input function threw an Error.

* // The first case will not throw as it does not match for the error message

* // thrown by the input function!

* assert.throws(throwingFirst, 'Second');

* // In the next example the message has no benefit over the message from the

* // error and since it is not clear if the user intended to actually match

* // against the error message, Node.js throws an `ERR_AMBIGUOUS_ARGUMENT` error.

* assert.throws(throwingSecond, 'Second');

* // TypeError [ERR_AMBIGUOUS_ARGUMENT]

*

* // The string is only used (as message) in case the function does not throw:

* assert.throws(notThrowing, 'Second');

* // AssertionError [ERR_ASSERTION]: Missing expected exception: Second

*

* // If it was intended to match for the error message do this instead:

* // It does not throw because the error messages match.

* assert.throws(throwingSecond, /Second$/);

*

* // If the error message does not match, an AssertionError is thrown.

* assert.throws(throwingFirst, /Second$/);

* // AssertionError [ERR_ASSERTION]

* ```

*

* Due to the confusing error-prone notation, avoid a string as the second

* argument.

* @since v0.1.21

*/

function throws(block: () => unknown, message?: string | Error): void;

function throws(block: () => unknown, error: AssertPredicate, message?: string | Error): void;

/**

* Asserts that the function `fn` does not throw an error.

*

* Using `assert.doesNotThrow()` is actually not useful because there

* is no benefit in catching an error and then rethrowing it. Instead, consider

* adding a comment next to the specific code path that should not throw and keep

* error messages as expressive as possible.

*

* When `assert.doesNotThrow()` is called, it will immediately call the `fn`function.

*

* If an error is thrown and it is the same type as that specified by the `error`parameter, then an `AssertionError` is thrown. If the error is of a

* different type, or if the `error` parameter is undefined, the error is

* propagated back to the caller.

*

* If specified, `error` can be a [`Class`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes),

* [`RegExp`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions) or a validation

* function. See {@link throws} for more details.

*

* The following, for instance, will throw the `TypeError` because there is no

* matching error type in the assertion:

*

* ```js

* import assert from 'assert/strict';

*

* assert.doesNotThrow(

* () => {

* throw new TypeError('Wrong value');

* },

* SyntaxError

* );

* ```

*

* However, the following will result in an `AssertionError` with the message

* 'Got unwanted exception...':

*

* ```js

* import assert from 'assert/strict';

*

* assert.doesNotThrow(

* () => {

* throw new TypeError('Wrong value');

* },

* TypeError

* );

* ```

*

* If an `AssertionError` is thrown and a value is provided for the `message`parameter, the value of `message` will be appended to the `AssertionError` message:

*

* ```js

* import assert from 'assert/strict';

*

* assert.doesNotThrow(

* () => {

* throw new TypeError('Wrong value');

* },

* /Wrong value/,

* 'Whoops'

* );

* // Throws: AssertionError: Got unwanted exception: Whoops

* ```

* @since v0.1.21

*/

function doesNotThrow(block: () => unknown, message?: string | Error): void;

function doesNotThrow(block: () => unknown, error: AssertPredicate, message?: string | Error): void;

/**

* Throws `value` if `value` is not `undefined` or `null`. This is useful when

* testing the `error` argument in callbacks. The stack trace contains all frames

* from the error passed to `ifError()` including the potential new frames for`ifError()` itself.

*

* ```js

* import assert from 'assert/strict';

*

* assert.ifError(null);

* // OK

* assert.ifError(0);

* // AssertionError [ERR_ASSERTION]: ifError got unwanted exception: 0

* assert.ifError('error');

* // AssertionError [ERR_ASSERTION]: ifError got unwanted exception: 'error'

* assert.ifError(new Error());

* // AssertionError [ERR_ASSERTION]: ifError got unwanted exception: Error

*

* // Create some random error frames.

* let err;

* (function errorFrame() {

* err = new Error('test error');

* })();

*

* (function ifErrorFrame() {

* assert.ifError(err);

* })();

* // AssertionError [ERR_ASSERTION]: ifError got unwanted exception: test error

* // at ifErrorFrame

* // at errorFrame

* ```

* @since v0.1.97

*/

function ifError(value: unknown): asserts value is null | undefined;

/**

* Awaits the `asyncFn` promise or, if `asyncFn` is a function, immediately

* calls the function and awaits the returned promise to complete. It will then

* check that the promise is rejected.

*

* If `asyncFn` is a function and it throws an error synchronously,`assert.rejects()` will return a rejected `Promise` with that error. If the

* function does not return a promise, `assert.rejects()` will return a rejected`Promise` with an `ERR_INVALID_RETURN_VALUE` error. In both cases the error

* handler is skipped.

*

* Besides the async nature to await the completion behaves identically to {@link throws}.

*

* If specified, `error` can be a [`Class`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes),

* [`RegExp`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions), a validation function,

* an object where each property will be tested for, or an instance of error where

* each property will be tested for including the non-enumerable `message` and`name` properties.

*

* If specified, `message` will be the message provided by the `AssertionError` if the `asyncFn` fails to reject.

*

* ```js

* import assert from 'assert/strict';

*

* await assert.rejects(

* async () => {

* throw new TypeError('Wrong value');

* },

* {

* name: 'TypeError',

* message: 'Wrong value'

* }

* );

* ```

*

* ```js

* import assert from 'assert/strict';

*

* await assert.rejects(

* async () => {

* throw new TypeError('Wrong value');

* },

* (err) => {

* assert.strictEqual(err.name, 'TypeError');

* assert.strictEqual(err.message, 'Wrong value');

* return true;

* }

* );

* ```

*

* ```js

* import assert from 'assert/strict';

*

* assert.rejects(

* Promise.reject(new Error('Wrong value')),

* Error

* ).then(() => {

* // ...

* });

* ```

*

* `error` cannot be a string. If a string is provided as the second

* argument, then `error` is assumed to be omitted and the string will be used for`message` instead. This can lead to easy-to-miss mistakes. Please read the

* example in {@link throws} carefully if using a string as the second

* argument gets considered.

* @since v10.0.0

*/

function rejects(block: (() => Promise<unknown>) | Promise<unknown>, message?: string | Error): Promise<void>;

function rejects(block: (() => Promise<unknown>) | Promise<unknown>, error: AssertPredicate, message?: string | Error): Promise<void>;

/**

* Awaits the `asyncFn` promise or, if `asyncFn` is a function, immediately

* calls the function and awaits the returned promise to complete. It will then

* check that the promise is not rejected.

*

* If `asyncFn` is a function and it throws an error synchronously,`assert.doesNotReject()` will return a rejected `Promise` with that error. If

* the function does not return a promise, `assert.doesNotReject()` will return a

* rejected `Promise` with an `ERR_INVALID_RETURN_VALUE` error. In both cases

* the error handler is skipped.

*

* Using `assert.doesNotReject()` is actually not useful because there is little

* benefit in catching a rejection and then rejecting it again. Instead, consider

* adding a comment next to the specific code path that should not reject and keep

* error messages as expressive as possible.

*

* If specified, `error` can be a [`Class`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes),

* [`RegExp`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions) or a validation

* function. See {@link throws} for more details.

*

* Besides the async nature to await the completion behaves identically to {@link doesNotThrow}.

*

* ```js

* import assert from 'assert/strict';

*

* await assert.doesNotReject(

* async () => {

* throw new TypeError('Wrong value');

* },

* SyntaxError

* );

* ```

*

* ```js

* import assert from 'assert/strict';

*

* assert.doesNotReject(Promise.reject(new TypeError('Wrong value')))

* .then(() => {

* // ...

* });

* ```

* @since v10.0.0

*/

function doesNotReject(block: (() => Promise<unknown>) | Promise<unknown>, message?: string | Error): Promise<void>;

function doesNotReject(block: (() => Promise<unknown>) | Promise<unknown>, error: AssertPredicate, message?: string | Error): Promise<void>;

/**

* Expects the `string` input to match the regular expression.

*

* ```js

* import assert from 'assert/strict';

*

* assert.match('I will fail', /pass/);

* // AssertionError [ERR_ASSERTION]: The input did not match the regular ...

*

* assert.match(123, /pass/);

* // AssertionError [ERR_ASSERTION]: The "string" argument must be of type string.

*

* assert.match('I will pass', /pass/);

* // OK

* ```

*

* If the values do not match, or if the `string` argument is of another type than`string`, an `AssertionError` is thrown with a `message` property set equal

* to the value of the `message` parameter. If the `message` parameter is

* undefined, a default error message is assigned. If the `message` parameter is an

* instance of an `Error` then it will be thrown instead of the `AssertionError`.

* @since v13.6.0, v12.16.0

*/

function match(value: string, regExp: RegExp, message?: string | Error): void;

/**

* Expects the `string` input not to match the regular expression.

*

* ```js

* import assert from 'assert/strict';

*

* assert.doesNotMatch('I will fail', /fail/);

* // AssertionError [ERR_ASSERTION]: The input was expected to not match the ...

*

* assert.doesNotMatch(123, /pass/);

* // AssertionError [ERR_ASSERTION]: The "string" argument must be of type string.

*

* assert.doesNotMatch('I will pass', /different/);

* // OK

* ```

*

* If the values do match, or if the `string` argument is of another type than`string`, an `AssertionError` is thrown with a `message` property set equal

* to the value of the `message` parameter. If the `message` parameter is

* undefined, a default error message is assigned. If the `message` parameter is an

* instance of an `Error` then it will be thrown instead of the `AssertionError`.

* @since v13.6.0, v12.16.0

*/

function doesNotMatch(value: string, regExp: RegExp, message?: string | Error): void;

const strict: Omit<typeof assert, 'equal' | 'notEqual' | 'deepEqual' | 'notDeepEqual' | 'ok' | 'strictEqual' | 'deepStrictEqual' | 'ifError' | 'strict'> & {

(value: unknown, message?: string | Error): asserts value;

equal: typeof strictEqual;

notEqual: typeof notStrictEqual;

deepEqual: typeof deepStrictEqual;

notDeepEqual: typeof notDeepStrictEqual;

// Mapped types and assertion functions are incompatible?

// TS2775: Assertions require every name in the call target

// to be declared with an explicit type annotation.

ok: typeof ok;

strictEqual: typeof strictEqual;

deepStrictEqual: typeof deepStrictEqual;

ifError: typeof ifError;

strict: typeof strict;

};

}

export = assert;

}

declare module 'node:assert' {

import assert = require('assert');

export = assert;

}