@types/chai-string

  • Version 1.4.2
  • Published
  • 5.38 kB
  • 1 dependency
  • MIT license

Install

npm i @types/chai-string
yarn add @types/chai-string
pnpm add @types/chai-string

Overview

TypeScript definitions for chai-string

Index

Variables

variable chaiString

const chaiString: any;

    Namespaces

    namespace global

    namespace global {}

      namespace global.Chai

      namespace global.Chai {}

        interface Assert

        interface Assert {}

          method containIgnoreCase

          containIgnoreCase: (val: string, exp: string, msg?: string) => void;

            method containIgnoreSpaces

            containIgnoreSpaces: (val: string, exp: string, msg?: string) => void;

              method endsWith

              endsWith: (val: string, exp: string, msg?: string) => void;

                method entriesCount

                entriesCount: (str: string, substr: string, count: number, msg?: string) => void;

                  method equalIgnoreCase

                  equalIgnoreCase: (val: string, exp: string, msg?: string) => void;

                    method equalIgnoreSpaces

                    equalIgnoreSpaces: (val: string, exp: string, msg?: string) => void;

                      method indexOf

                      indexOf: (str: string, substr: string, index: number, msg?: string) => void;

                        method notContainIgnoreCase

                        notContainIgnoreCase: (val: string, exp: string, msg?: string) => void;

                          method notContainIgnoreSpaces

                          notContainIgnoreSpaces: (val: string, exp: string, msg?: string) => void;

                            method notEndsWith

                            notEndsWith: (val: string, exp: string, msg?: string) => void;

                              method notEqualIgnoreCase

                              notEqualIgnoreCase: (val: string, exp: string, msg?: string) => void;

                                method notEqualIgnoreSpaces

                                notEqualIgnoreSpaces: (val: string, exp: string, msg?: string) => void;

                                  method notPalindrome

                                  notPalindrome: (val: string, msg?: string) => void;

                                    method notReverseOf

                                    notReverseOf: (val: string, exp: string, msg?: string) => void;

                                      method notSingleLine

                                      notSingleLine: (val: string, msg?: string) => void;

                                        method notStartsWith

                                        notStartsWith: (val: string, exp: string, msg?: string) => void;

                                          method palindrome

                                          palindrome: (val: string, msg?: string) => void;

                                            method reverseOf

                                            reverseOf: (val: string, exp: string, msg?: string) => void;

                                              method singleLine

                                              singleLine: (val: string, msg?: string) => void;

                                                method startsWith

                                                startsWith: (val: string, exp: string, msg?: string) => void;

                                                  interface Assertion

                                                  interface Assertion extends LanguageChains, NumericComparison, TypeComparison {}

                                                    method containIgnoreCase

                                                    containIgnoreCase: (expected: string, msg?: string) => Assertion;

                                                      method containIgnoreSpaces

                                                      containIgnoreSpaces: (expected: string, msg?: string) => Assertion;

                                                        method endsWith

                                                        endsWith: (expected: string, message?: string) => Assertion;

                                                          method endWith

                                                          endWith: (expected: string, message?: string) => Assertion;

                                                            method entriesCount

                                                            entriesCount: (substr: string, expected: number, message?: string) => Assertion;

                                                              method equalIgnoreCase

                                                              equalIgnoreCase: (expected: string, message?: string) => Assertion;

                                                                method equalIgnoreSpaces

                                                                equalIgnoreSpaces: (expected: string, message?: string) => Assertion;

                                                                  method indexOf

                                                                  indexOf: (str: string, substr: string, index: number, msg?: string) => Assertion;

                                                                    method palindrome

                                                                    palindrome: (message?: string) => Assertion;

                                                                      method reverseOf

                                                                      reverseOf: (message?: string) => Assertion;

                                                                        method singleLine

                                                                        singleLine: (message?: string) => Assertion;

                                                                          method startsWith

                                                                          startsWith: (expected: string, message?: string) => Assertion;

                                                                            method startWith

                                                                            startWith: (expected: string, message?: string) => Assertion;

                                                                              Package Files (1)

                                                                              Dependencies (1)

                                                                              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/chai-string.

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