@types/power-assert

  • Version 1.5.3
  • Published
  • 5.2 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

variable doesNotThrow

var doesNotThrow: {
(block: Function, message?: string): void;
(block: Function, error: Function, message?: string): void;
(block: Function, error: RegExp, message?: string): void;
(block: Function, error: (err: any) => boolean, message?: string): void;
};

    variable strict

    const strict: typeof assert;

      variable throws

      var throws: {
      (block: Function, message?: string): void;
      (block: Function, error: Function, message?: string): void;
      (block: Function, error: RegExp, message?: string): void;
      (block: Function, error: (err: any) => boolean, message?: string): void;
      };

        Functions

        function assert

        assert: typeof assert;

          function customize

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

            function deepEqual

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

              function deepStrictEqual

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

                function equal

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

                  function fail

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

                    function ifError

                    ifError: (value: any) => void;

                      function notDeepEqual

                      notDeepEqual: (acutal: any, expected: any, message?: string) => void;

                        function notDeepStrictEqual

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

                          function notEqual

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

                            function notStrictEqual

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

                              function ok

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

                                function strictEqual

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

                                  Classes

                                  class AssertionError

                                  class AssertionError implements Error {}

                                    constructor

                                    constructor(options?: {
                                    message?: string;
                                    actual?: any;
                                    expected?: any;
                                    operator?: string;
                                    stackStartFunction?: Function;
                                    });

                                      property actual

                                      actual: any;

                                        property expected

                                        expected: any;

                                          property generatedMessage

                                          generatedMessage: boolean;

                                            property message

                                            message: string;

                                              property name

                                              name: string;

                                                property operator

                                                operator: string;

                                                  Interfaces

                                                  interface Options

                                                  interface Options {}

                                                    property assertion

                                                    assertion?: empower.Options;

                                                      property output

                                                      output?: powerAssertFormatter.Options;

                                                        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>