Logo for jsDocs.io

@types/store

  • Version 2.0.5
  • Published
  • 8.29 kB
  • No dependencies
  • MIT license

Install

npm i @types/store
yarn add @types/store
pnpm add @types/store

Overview

TypeScript definitions for store

Index

Variables

Namespaces

Variables

variable engine

const engine: StoreJsEngine;

    variable storage

    const storage: StoreJsStorage;

      variable store

      const store: StoreJsAPI;

        Namespaces

        namespace store

        module 'store' {}

          variable store

          const store: StoreJsAPI;

            namespace store/dist/store.legacy

            module 'store/dist/store.legacy' {}

              variable store

              const store: StoreJsAPI;

                namespace store/dist/store.legacy.min

                module 'store/dist/store.legacy.min' {}

                  variable store

                  const store: StoreJsAPI;

                    namespace store/dist/store.modern

                    module 'store/dist/store.modern' {}

                      variable store

                      const store: StoreJsAPI;

                        namespace store/dist/store.modern.min

                        module 'store/dist/store.modern.min' {}

                          variable store

                          const store: StoreJsAPI;

                            namespace store/plugins/all

                            module 'store/plugins/all' {}

                              variable Function

                              var Function: FunctionConstructor;

                                interface Function

                                interface Function {}

                                  property arguments

                                  arguments: any;

                                    property caller

                                    caller: Function;

                                      property length

                                      readonly length: number;

                                        property prototype

                                        prototype: any;

                                          method apply

                                          apply: (this: Function, thisArg: any, argArray?: any) => any;

                                            method bind

                                            bind: (this: Function, thisArg: any, ...argArray: any[]) => any;

                                              method call

                                              call: (this: Function, thisArg: any, ...argArray: any[]) => any;

                                                method toString

                                                toString: () => string;

                                                  interface Function

                                                  interface Function {}

                                                    property name

                                                    readonly name: string;

                                                      interface Function

                                                      interface Function {}

                                                        method [Symbol.hasInstance]

                                                        [Symbol.hasInstance]: (value: any) => boolean;

                                                          namespace store/plugins/defaults

                                                          module 'store/plugins/defaults' {}

                                                            variable Function

                                                            var Function: FunctionConstructor;

                                                              interface Function

                                                              interface Function {}

                                                                property arguments

                                                                arguments: any;

                                                                  property caller

                                                                  caller: Function;

                                                                    property length

                                                                    readonly length: number;

                                                                      property prototype

                                                                      prototype: any;

                                                                        method apply

                                                                        apply: (this: Function, thisArg: any, argArray?: any) => any;

                                                                          method bind

                                                                          bind: (this: Function, thisArg: any, ...argArray: any[]) => any;

                                                                            method call

                                                                            call: (this: Function, thisArg: any, ...argArray: any[]) => any;

                                                                              method toString

                                                                              toString: () => string;

                                                                                interface Function

                                                                                interface Function {}

                                                                                  property name

                                                                                  readonly name: string;

                                                                                    interface Function

                                                                                    interface Function {}

                                                                                      method [Symbol.hasInstance]

                                                                                      [Symbol.hasInstance]: (value: any) => boolean;

                                                                                        namespace store/plugins/dump

                                                                                        module 'store/plugins/dump' {}

                                                                                          variable Function

                                                                                          var Function: FunctionConstructor;

                                                                                            interface Function

                                                                                            interface Function {}

                                                                                              property arguments

                                                                                              arguments: any;

                                                                                                property caller

                                                                                                caller: Function;

                                                                                                  property length

                                                                                                  readonly length: number;

                                                                                                    property prototype

                                                                                                    prototype: any;

                                                                                                      method apply

                                                                                                      apply: (this: Function, thisArg: any, argArray?: any) => any;

                                                                                                        method bind

                                                                                                        bind: (this: Function, thisArg: any, ...argArray: any[]) => any;

                                                                                                          method call

                                                                                                          call: (this: Function, thisArg: any, ...argArray: any[]) => any;

                                                                                                            method toString

                                                                                                            toString: () => string;

                                                                                                              interface Function

                                                                                                              interface Function {}

                                                                                                                property name

                                                                                                                readonly name: string;

                                                                                                                  interface Function

                                                                                                                  interface Function {}

                                                                                                                    method [Symbol.hasInstance]

                                                                                                                    [Symbol.hasInstance]: (value: any) => boolean;

                                                                                                                      namespace store/plugins/events

                                                                                                                      module 'store/plugins/events' {}

                                                                                                                        variable Function

                                                                                                                        var Function: FunctionConstructor;

                                                                                                                          interface Function

                                                                                                                          interface Function {}

                                                                                                                            property arguments

                                                                                                                            arguments: any;

                                                                                                                              property caller

                                                                                                                              caller: Function;

                                                                                                                                property length

                                                                                                                                readonly length: number;

                                                                                                                                  property prototype

                                                                                                                                  prototype: any;

                                                                                                                                    method apply

                                                                                                                                    apply: (this: Function, thisArg: any, argArray?: any) => any;

                                                                                                                                      method bind

                                                                                                                                      bind: (this: Function, thisArg: any, ...argArray: any[]) => any;

                                                                                                                                        method call

                                                                                                                                        call: (this: Function, thisArg: any, ...argArray: any[]) => any;

                                                                                                                                          method toString

                                                                                                                                          toString: () => string;

                                                                                                                                            interface Function

                                                                                                                                            interface Function {}

                                                                                                                                              property name

                                                                                                                                              readonly name: string;

                                                                                                                                                interface Function

                                                                                                                                                interface Function {}

                                                                                                                                                  method [Symbol.hasInstance]

                                                                                                                                                  [Symbol.hasInstance]: (value: any) => boolean;

                                                                                                                                                    namespace store/plugins/expire

                                                                                                                                                    module 'store/plugins/expire' {}

                                                                                                                                                      variable Function

                                                                                                                                                      var Function: FunctionConstructor;

                                                                                                                                                        interface Function

                                                                                                                                                        interface Function {}

                                                                                                                                                          property arguments

                                                                                                                                                          arguments: any;

                                                                                                                                                            property caller

                                                                                                                                                            caller: Function;

                                                                                                                                                              property length

                                                                                                                                                              readonly length: number;

                                                                                                                                                                property prototype

                                                                                                                                                                prototype: any;

                                                                                                                                                                  method apply

                                                                                                                                                                  apply: (this: Function, thisArg: any, argArray?: any) => any;

                                                                                                                                                                    method bind

                                                                                                                                                                    bind: (this: Function, thisArg: any, ...argArray: any[]) => any;

                                                                                                                                                                      method call

                                                                                                                                                                      call: (this: Function, thisArg: any, ...argArray: any[]) => any;

                                                                                                                                                                        method toString

                                                                                                                                                                        toString: () => string;

                                                                                                                                                                          interface Function

                                                                                                                                                                          interface Function {}

                                                                                                                                                                            property name

                                                                                                                                                                            readonly name: string;

                                                                                                                                                                              interface Function

                                                                                                                                                                              interface Function {}

                                                                                                                                                                                method [Symbol.hasInstance]

                                                                                                                                                                                [Symbol.hasInstance]: (value: any) => boolean;

                                                                                                                                                                                  namespace store/plugins/observe

                                                                                                                                                                                  module 'store/plugins/observe' {}

                                                                                                                                                                                    variable Function

                                                                                                                                                                                    var Function: FunctionConstructor;

                                                                                                                                                                                      interface Function

                                                                                                                                                                                      interface Function {}

                                                                                                                                                                                        property arguments

                                                                                                                                                                                        arguments: any;

                                                                                                                                                                                          property caller

                                                                                                                                                                                          caller: Function;

                                                                                                                                                                                            property length

                                                                                                                                                                                            readonly length: number;

                                                                                                                                                                                              property prototype

                                                                                                                                                                                              prototype: any;

                                                                                                                                                                                                method apply

                                                                                                                                                                                                apply: (this: Function, thisArg: any, argArray?: any) => any;

                                                                                                                                                                                                  method bind

                                                                                                                                                                                                  bind: (this: Function, thisArg: any, ...argArray: any[]) => any;

                                                                                                                                                                                                    method call

                                                                                                                                                                                                    call: (this: Function, thisArg: any, ...argArray: any[]) => any;

                                                                                                                                                                                                      method toString

                                                                                                                                                                                                      toString: () => string;

                                                                                                                                                                                                        interface Function

                                                                                                                                                                                                        interface Function {}

                                                                                                                                                                                                          property name

                                                                                                                                                                                                          readonly name: string;

                                                                                                                                                                                                            interface Function

                                                                                                                                                                                                            interface Function {}

                                                                                                                                                                                                              method [Symbol.hasInstance]

                                                                                                                                                                                                              [Symbol.hasInstance]: (value: any) => boolean;

                                                                                                                                                                                                                namespace store/plugins/operations

                                                                                                                                                                                                                module 'store/plugins/operations' {}

                                                                                                                                                                                                                  variable Function

                                                                                                                                                                                                                  var Function: FunctionConstructor;

                                                                                                                                                                                                                    interface Function

                                                                                                                                                                                                                    interface Function {}

                                                                                                                                                                                                                      property arguments

                                                                                                                                                                                                                      arguments: any;

                                                                                                                                                                                                                        property caller

                                                                                                                                                                                                                        caller: Function;

                                                                                                                                                                                                                          property length

                                                                                                                                                                                                                          readonly length: number;

                                                                                                                                                                                                                            property prototype

                                                                                                                                                                                                                            prototype: any;

                                                                                                                                                                                                                              method apply

                                                                                                                                                                                                                              apply: (this: Function, thisArg: any, argArray?: any) => any;

                                                                                                                                                                                                                                method bind

                                                                                                                                                                                                                                bind: (this: Function, thisArg: any, ...argArray: any[]) => any;

                                                                                                                                                                                                                                  method call

                                                                                                                                                                                                                                  call: (this: Function, thisArg: any, ...argArray: any[]) => any;

                                                                                                                                                                                                                                    method toString

                                                                                                                                                                                                                                    toString: () => string;

                                                                                                                                                                                                                                      interface Function

                                                                                                                                                                                                                                      interface Function {}

                                                                                                                                                                                                                                        property name

                                                                                                                                                                                                                                        readonly name: string;

                                                                                                                                                                                                                                          interface Function

                                                                                                                                                                                                                                          interface Function {}

                                                                                                                                                                                                                                            method [Symbol.hasInstance]

                                                                                                                                                                                                                                            [Symbol.hasInstance]: (value: any) => boolean;

                                                                                                                                                                                                                                              namespace store/plugins/update

                                                                                                                                                                                                                                              module 'store/plugins/update' {}

                                                                                                                                                                                                                                                variable Function

                                                                                                                                                                                                                                                var Function: FunctionConstructor;

                                                                                                                                                                                                                                                  interface Function

                                                                                                                                                                                                                                                  interface Function {}

                                                                                                                                                                                                                                                    property arguments

                                                                                                                                                                                                                                                    arguments: any;

                                                                                                                                                                                                                                                      property caller

                                                                                                                                                                                                                                                      caller: Function;

                                                                                                                                                                                                                                                        property length

                                                                                                                                                                                                                                                        readonly length: number;

                                                                                                                                                                                                                                                          property prototype

                                                                                                                                                                                                                                                          prototype: any;

                                                                                                                                                                                                                                                            method apply

                                                                                                                                                                                                                                                            apply: (this: Function, thisArg: any, argArray?: any) => any;

                                                                                                                                                                                                                                                              method bind

                                                                                                                                                                                                                                                              bind: (this: Function, thisArg: any, ...argArray: any[]) => any;

                                                                                                                                                                                                                                                                method call

                                                                                                                                                                                                                                                                call: (this: Function, thisArg: any, ...argArray: any[]) => any;

                                                                                                                                                                                                                                                                  method toString

                                                                                                                                                                                                                                                                  toString: () => string;

                                                                                                                                                                                                                                                                    interface Function

                                                                                                                                                                                                                                                                    interface Function {}

                                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                                      readonly name: string;

                                                                                                                                                                                                                                                                        interface Function

                                                                                                                                                                                                                                                                        interface Function {}

                                                                                                                                                                                                                                                                          method [Symbol.hasInstance]

                                                                                                                                                                                                                                                                          [Symbol.hasInstance]: (value: any) => boolean;

                                                                                                                                                                                                                                                                            namespace store/plugins/v1-backcompat

                                                                                                                                                                                                                                                                            module 'store/plugins/v1-backcompat' {}

                                                                                                                                                                                                                                                                              variable Function

                                                                                                                                                                                                                                                                              var Function: FunctionConstructor;

                                                                                                                                                                                                                                                                                interface Function

                                                                                                                                                                                                                                                                                interface Function {}

                                                                                                                                                                                                                                                                                  property arguments

                                                                                                                                                                                                                                                                                  arguments: any;

                                                                                                                                                                                                                                                                                    property caller

                                                                                                                                                                                                                                                                                    caller: Function;

                                                                                                                                                                                                                                                                                      property length

                                                                                                                                                                                                                                                                                      readonly length: number;

                                                                                                                                                                                                                                                                                        property prototype

                                                                                                                                                                                                                                                                                        prototype: any;

                                                                                                                                                                                                                                                                                          method apply

                                                                                                                                                                                                                                                                                          apply: (this: Function, thisArg: any, argArray?: any) => any;

                                                                                                                                                                                                                                                                                            method bind

                                                                                                                                                                                                                                                                                            bind: (this: Function, thisArg: any, ...argArray: any[]) => any;

                                                                                                                                                                                                                                                                                              method call

                                                                                                                                                                                                                                                                                              call: (this: Function, thisArg: any, ...argArray: any[]) => any;

                                                                                                                                                                                                                                                                                                method toString

                                                                                                                                                                                                                                                                                                toString: () => string;

                                                                                                                                                                                                                                                                                                  interface Function

                                                                                                                                                                                                                                                                                                  interface Function {}

                                                                                                                                                                                                                                                                                                    property name

                                                                                                                                                                                                                                                                                                    readonly name: string;

                                                                                                                                                                                                                                                                                                      interface Function

                                                                                                                                                                                                                                                                                                      interface Function {}

                                                                                                                                                                                                                                                                                                        method [Symbol.hasInstance]

                                                                                                                                                                                                                                                                                                        [Symbol.hasInstance]: (value: any) => boolean;

                                                                                                                                                                                                                                                                                                          namespace store/src/store-engine

                                                                                                                                                                                                                                                                                                          module 'store/src/store-engine' {}

                                                                                                                                                                                                                                                                                                            variable engine

                                                                                                                                                                                                                                                                                                            const engine: StoreJsEngine;

                                                                                                                                                                                                                                                                                                              namespace store/storages/cookieStorage

                                                                                                                                                                                                                                                                                                              module 'store/storages/cookieStorage' {}

                                                                                                                                                                                                                                                                                                                variable storage

                                                                                                                                                                                                                                                                                                                const storage: StoreJsStorage;

                                                                                                                                                                                                                                                                                                                  namespace store/storages/localStorage

                                                                                                                                                                                                                                                                                                                  module 'store/storages/localStorage' {}

                                                                                                                                                                                                                                                                                                                    variable storage

                                                                                                                                                                                                                                                                                                                    const storage: StoreJsStorage;

                                                                                                                                                                                                                                                                                                                      namespace store/storages/memoryStorage

                                                                                                                                                                                                                                                                                                                      module 'store/storages/memoryStorage' {}

                                                                                                                                                                                                                                                                                                                        variable storage

                                                                                                                                                                                                                                                                                                                        const storage: StoreJsStorage;

                                                                                                                                                                                                                                                                                                                          namespace store/storages/oldFF-globalStorage

                                                                                                                                                                                                                                                                                                                          module 'store/storages/oldFF-globalStorage' {}

                                                                                                                                                                                                                                                                                                                            variable storage

                                                                                                                                                                                                                                                                                                                            const storage: StoreJsStorage;

                                                                                                                                                                                                                                                                                                                              namespace store/storages/oldIE-userDataStorage

                                                                                                                                                                                                                                                                                                                              module 'store/storages/oldIE-userDataStorage' {}

                                                                                                                                                                                                                                                                                                                                variable storage

                                                                                                                                                                                                                                                                                                                                const storage: StoreJsStorage;

                                                                                                                                                                                                                                                                                                                                  namespace store/storages/sessionStorage

                                                                                                                                                                                                                                                                                                                                  module 'store/storages/sessionStorage' {}

                                                                                                                                                                                                                                                                                                                                    variable storage

                                                                                                                                                                                                                                                                                                                                    const storage: StoreJsStorage;

                                                                                                                                                                                                                                                                                                                                      Package Files (4)

                                                                                                                                                                                                                                                                                                                                      Dependencies (0)

                                                                                                                                                                                                                                                                                                                                      No dependencies.

                                                                                                                                                                                                                                                                                                                                      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/store.

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