/**
 * The `node:assert` module provides a set of assertion functions for verifying
 * invariants.
 * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/assert.js)
 */
declare module "assert" {
    import strict = require("assert/strict");
    /**
     * An alias of {@link assert.ok}.
     * @since v0.5.9
     * @param value The input that is checked for being truthy.
     */
    function assert(value: unknown, message?: string | Error): asserts value;
    const kOptions: unique symbol;
    namespace assert {
        type AssertMethodNames =
            | "deepEqual"
            | "deepStrictEqual"
            | "doesNotMatch"
            | "doesNotReject"
            | "doesNotThrow"
            | "equal"
            | "fail"
            | "ifError"
            | "match"
            | "notDeepEqual"
            | "notDeepStrictEqual"
            | "notEqual"
            | "notStrictEqual"
            | "ok"
            | "partialDeepStrictEqual"
            | "rejects"
            | "strictEqual"
            | "throws";
        interface AssertOptions {
            /**
             * If set to `'full'`, shows the full diff in assertion errors.
             * @default 'simple'
             */
            diff?: "simple" | "full" | undefined;
            /**
             * If set to `true`, non-strict methods behave like their
             * corresponding strict methods.
             * @default true
             */
            strict?: boolean | undefined;
        }
        interface Assert extends Pick<typeof assert, AssertMethodNames> {
            readonly [kOptions]: AssertOptions & { strict: false };
        }
        interface AssertStrict extends Pick<typeof strict, AssertMethodNames> {
            readonly [kOptions]: AssertOptions & { strict: true };
        }
        /**
         * The `Assert` class allows creating independent assertion instances with custom options.
         * @since v24.6.0
         */
        var Assert: {
            /**
             * Creates a new assertion instance. The `diff` option controls the verbosity of diffs in assertion error messages.
             *
             * ```js
             * const { Assert } = require('node:assert');
             * const assertInstance = new Assert({ diff: 'full' });
             * assertInstance.deepStrictEqual({ a: 1 }, { a: 2 });
             * // Shows a full diff in the error message.
             * ```
             *
             * **Important**: When destructuring assertion methods from an `Assert` instance,
             * the methods lose their connection to the instance's configuration options (such as `diff` and `strict` settings).
             * The destructured methods will fall back to default behavior instead.
             *
             * ```js
             * const myAssert = new Assert({ diff: 'full' });
             *
             * // This works as expected - uses 'full' diff
             * myAssert.strictEqual({ a: 1 }, { b: { c: 1 } });
             *
             * // This loses the 'full' diff setting - falls back to default 'simple' diff
             * const { strictEqual } = myAssert;
             * strictEqual({ a: 1 }, { b: { c: 1 } });
             * ```
             *
             * When destructured, methods lose access to the instance's `this` context and revert to default assertion behavior
             * (diff: 'simple', non-strict mode).
             * To maintain custom options when using destructured methods, avoid
             * destructuring and call methods directly on the instance.
             * @since v24.6.0
             */
            new(
                options?: AssertOptions & { strict?: true },
            ): AssertStrict;
            new(
                options: AssertOptions,
            ): Assert;
        };
        interface AssertionErrorOptions {
            /**
             * If provided, the error message is set to this value.
             */
            message?: string | undefined;
            /**
             * The `actual` property on the error instance.
             */
            actual?: unknown;
            /**
             * The `expected` property on the error instance.
             */
            expected?: unknown;
            /**
             * The `operator` property on the error instance.
             */
            operator?: string | undefined;
            /**
             * If provided, the generated stack trace omits frames before this function.
             */
            stackStartFn?: Function | undefined;
            /**
             * If set to `'full'`, shows the full diff in assertion errors.
             * @default 'simple'
             */
            diff?: "simple" | "full" | undefined;
        }
        /**
         * Indicates the failure of an assertion. All errors thrown by the `node:assert` module will be instances of the `AssertionError` class.
         */
        class AssertionError extends Error {
            constructor(options: AssertionErrorOptions);
            /**
             * Set to the `actual` argument for methods such as {@link assert.strictEqual()}.
             */
            actual: unknown;
            /**
             * Set to the `expected` argument for methods such as {@link assert.strictEqual()}.
             */
            expected: unknown;
            /**
             * Indicates if the message was auto-generated (`true`) or not.
             */
            generatedMessage: boolean;
            /**
             * Value is always `ERR_ASSERTION` to show that the error is an assertion error.
             */
            code: "ERR_ASSERTION";
            /**
             * Set to the passed in operator value.
             */
            operator: string;
        }
        /**
         * This feature is deprecated and will be removed in a future version.
         * Please consider using alternatives such as the `mock` helper function.
         * @since v14.2.0, v12.19.0
         * @deprecated Deprecated
         */
        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 'node: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 A function that wraps `fn`.
             */
            calls(exact?: number): () => void;
            calls(fn: undefined, exact?: number): () => void;
            calls<Func extends (...args: any[]) => any>(fn: Func, exact?: number): Func;
            calls<Func extends (...args: any[]) => any>(fn?: Func, exact?: number): Func | (() => void);
            /**
             * Example:
             *
             * ```js
             * import assert from 'node:assert';
             *
             * const tracker = new assert.CallTracker();
             *
             * function func() {}
             * const callsfunc = tracker.calls(func);
             * callsfunc(1, 2, 3);
             *
             * assert.deepStrictEqual(tracker.getCalls(callsfunc),
             *                        [{ thisArg: undefined, arguments: [1, 2, 3] }]);
             * ```
             * @since v18.8.0, v16.18.0
             * @return An array with all the calls to a tracked function.
             */
            getCalls(fn: Function): CallTrackerCall[];
            /**
             * 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 'node: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);
             *
             * // Returns an array containing information on callsfunc()
             * console.log(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 An array of objects containing information about the wrapper functions returned by {@link tracker.calls()}.
             */
            report(): CallTrackerReportInformation[];
            /**
             * Reset calls of the call tracker. If a tracked function is passed as an argument, the calls will be reset for it.
             * If no arguments are passed, all tracked functions will be reset.
             *
             * ```js
             * import assert from 'node:assert';
             *
             * const tracker = new assert.CallTracker();
             *
             * function func() {}
             * const callsfunc = tracker.calls(func);
             *
             * callsfunc();
             * // Tracker was called once
             * assert.strictEqual(tracker.getCalls(callsfunc).length, 1);
             *
             * tracker.reset(callsfunc);
             * assert.strictEqual(tracker.getCalls(callsfunc).length, 0);
             * ```
             * @since v18.8.0, v16.18.0
             * @param fn a tracked