Logo for jsDocs.io

@types/power-assert

  • Version 1.5.12
  • Published
  • 5.4 kB
  • 2 dependencies
  • MIT license

Install

npm i @types/power-assert
yarn add @types/power-assert
pnpm add @types/power-assert

Overview

TypeScript definitions for power-assert

Index

Variables

Functions

Classes

Interfaces

Variables

variable doesNotThrow

const doesNotThrow: {
    (block: () => unknown, message?: string): void;
    (
        block: () => unknown,
        error: RegExp | (new () => object) | ((err: any) => boolean),
        message?: string
    ): void;
};

    variable strict

    const strict: typeof assert;

      variable throws

      const throws: {
          (block: () => unknown, message?: string): void;
          (
              block: () => unknown,
              error: RegExp | (new () => object) | ((err: unknown) => boolean),
              message?: string
          ): void;
      };

        Functions

        function assert

        assert: typeof assert;

          function customize

          customize: (options: Options) => typeof assert;

            function deepEqual

            deepEqual: (actual: unknown, expected: unknown, message?: string) => void;

              function deepStrictEqual

              deepStrictEqual: (actual: unknown, expected: unknown, message?: string) => void;

                function equal

                equal: (actual: unknown, expected: unknown, message?: string) => void;

                  function fail

                  fail: (
                      actual?: unknown,
                      expected?: unknown,
                      message?: string,
                      operator?: string
                  ) => never;

                    function ifError

                    ifError: (value: unknown) => void | undefined;

                      function notDeepEqual

                      notDeepEqual: (actual: unknown, expected: unknown, message?: string) => void;

                        function notDeepStrictEqual

                        notDeepStrictEqual: (
                            actual: unknown,
                            expected: unknown,
                            message?: string
                        ) => void;

                          function notEqual

                          notEqual: (actual: unknown, expected: unknown, message?: string) => void;

                            function notStrictEqual

                            notStrictEqual: (actual: unknown, expected: unknown, message?: string) => void;

                              function ok

                              ok: (value: unknown, message?: string) => void;

                                function strictEqual

                                strictEqual: (actual: unknown, expected: unknown, message?: string) => void;

                                  Classes

                                  class AssertionError

                                  class AssertionError implements Error {}

                                    constructor

                                    constructor(options?: {
                                        message?: string | undefined;
                                        actual?: unknown;
                                        expected?: unknown;
                                        operator?: string | undefined;
                                        stackStartFunction?: () => void | undefined;
                                    });

                                      property actual

                                      actual: {};

                                        property expected

                                        expected: {};

                                          property generatedMessage

                                          generatedMessage: boolean;

                                            property message

                                            message: string;

                                              property name

                                              name: string;

                                                property operator

                                                operator: string;

                                                  Interfaces

                                                  interface Options

                                                  interface Options {}

                                                    property assertion

                                                    assertion?: EmpowerOptions | undefined;

                                                      property output

                                                      output?: PowerAssertFormatterOptions | undefined;

                                                        Package Files (1)

                                                        Dependencies (2)

                                                        Dev Dependencies (0)

                                                        No dev dependencies.

                                                        Peer Dependencies (0)

                                                        No peer dependencies.

                                                        Badge

                                                        To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                        You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/power-assert.

                                                        • Markdown
                                                          [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/power-assert)
                                                        • HTML
                                                          <a href="https://www.jsdocs.io/package/@types/power-assert"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>