@types/nconf

  • Version 0.10.3
  • Published
  • 7.28 kB
  • No dependencies
  • MIT license

Install

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

Overview

TypeScript definitions for nconf

Index

Variables

variable formats

var formats: IFormats;

    variable sources

    var sources: any[];

      variable stores

      var stores: any;

        variable version

        var version: string;

          Functions

          function add

          add: (name: string, options?: IOptions) => Provider;

            function any

            any: (keys: string[], callback?: ICallbackFunction) => any;

              function argv

              argv: (options?: IOptions) => Provider;

                function clear

                clear: (key: string, callback?: ICallbackFunction) => any;

                  function create

                  create: (name: string, options: IOptions) => IStore;

                    function defaults

                    defaults: (options?: IOptions) => Provider;

                      function env

                      env: { (options?: IOptions): Provider; (separator: string): Provider };

                        function file

                        file: {
                        (name: string, options?: IFileOptions): Provider;
                        (name: string, filename: string): Provider;
                        (options: IFileOptions): Provider;
                        };

                          function get

                          get: (key?: string, callback?: ICallbackFunction) => any;

                            function init

                            init: (options?: IOptions) => void;

                              function key

                              key: (...values: any[]) => string;

                                function load

                                load: (callback?: ICallbackFunction) => any;

                                  function loadFiles

                                  loadFiles: (files: any, callback?: ICallbackFunction) => void;

                                    function loadFilesSync

                                    loadFilesSync: (files: any, callback?: ICallbackFunction) => void;

                                      function loadSources

                                      loadSources: () => any;

                                        function merge

                                        merge: (key: string, value: any, callback?: ICallbackFunction) => any;

                                          function mergeSources

                                          mergeSources: (data: any) => void;

                                            function overrides

                                            overrides: (options?: IOptions) => Provider;

                                              function path

                                              path: (key: any) => any[];

                                                function remove

                                                remove: (name: string) => void;

                                                  function required

                                                  required: (keys: string[]) => Provider;

                                                    function reset

                                                    reset: (callback?: ICallbackFunction) => any;

                                                      function save

                                                      save: (value: any, callback?: ICallbackFunction) => any;

                                                        function set

                                                        set: (key: string, value: any, callback?: ICallbackFunction) => any;

                                                          function use

                                                          use: (name: string, options?: IOptions) => Provider;

                                                            Classes

                                                            class Provider

                                                            class Provider {}

                                                              constructor

                                                              constructor(options?: IOptions);

                                                                property sources

                                                                sources: any[];

                                                                  property stores

                                                                  stores: any;

                                                                    method add

                                                                    add: (name: string, options?: IOptions) => Provider;

                                                                      method any

                                                                      any: (keys: string[], callback?: ICallbackFunction) => any;

                                                                        method argv

                                                                        argv: (options?: IOptions) => Provider;

                                                                          method clear

                                                                          clear: (key: string, callback?: ICallbackFunction) => any;

                                                                            method create

                                                                            create: (name: string, options: IOptions) => IStore;

                                                                              method defaults

                                                                              defaults: (options?: IOptions) => Provider;

                                                                                method env

                                                                                env: { (options?: IOptions): Provider; (separator: string): Provider };

                                                                                  method file

                                                                                  file: {
                                                                                  (name: string, options?: IFileOptions): Provider;
                                                                                  (name: string, filename: string): Provider;
                                                                                  (options: IFileOptions): Provider;
                                                                                  };

                                                                                    method get

                                                                                    get: (key?: string, callback?: ICallbackFunction) => any;

                                                                                      method init

                                                                                      init: (options?: IOptions) => void;

                                                                                        method load

                                                                                        load: (callback?: ICallbackFunction) => any;

                                                                                          method loadSources

                                                                                          loadSources: () => any;

                                                                                            method merge

                                                                                            merge: (key: string, value: any, callback?: ICallbackFunction) => any;

                                                                                              method mergeSources

                                                                                              mergeSources: (data: any) => void;

                                                                                                method overrides

                                                                                                overrides: (options?: IOptions) => Provider;

                                                                                                  method remove

                                                                                                  remove: (name: string) => void;

                                                                                                    method required

                                                                                                    required: (keys: string[]) => Provider;

                                                                                                      method reset

                                                                                                      reset: (callback?: ICallbackFunction) => any;

                                                                                                        method save

                                                                                                        save: (value: any, callback?: ICallbackFunction) => any;

                                                                                                          method set

                                                                                                          set: (key: string, value: any, callback?: ICallbackFunction) => any;

                                                                                                            method use

                                                                                                            use: (name: string, options?: IOptions) => Provider;

                                                                                                              Interfaces

                                                                                                              interface ICallbackFunction

                                                                                                              interface ICallbackFunction {}

                                                                                                                call signature

                                                                                                                (err: Error): void;

                                                                                                                  interface IFileOptions

                                                                                                                  interface IFileOptions {}

                                                                                                                    property dir

                                                                                                                    dir?: string | undefined;

                                                                                                                      property file

                                                                                                                      file?: string | undefined;

                                                                                                                        property format

                                                                                                                        format?: IFormat | undefined;

                                                                                                                          property json_spacing

                                                                                                                          json_spacing?: number | undefined;

                                                                                                                            property search

                                                                                                                            search?: boolean | undefined;

                                                                                                                              property secure

                                                                                                                              secure?: ISecureFileOptions | undefined;

                                                                                                                                property type

                                                                                                                                type?: string | undefined;

                                                                                                                                  interface IFormat

                                                                                                                                  interface IFormat {}

                                                                                                                                    property parse

                                                                                                                                    parse: (str: string) => any;

                                                                                                                                      property stringify

                                                                                                                                      stringify: (obj: any, replacer: any, spacing?: any) => string;

                                                                                                                                        interface IFormats

                                                                                                                                        interface IFormats {}

                                                                                                                                          property ini

                                                                                                                                          ini: IFormat;

                                                                                                                                            property json

                                                                                                                                            json: IFormat;

                                                                                                                                              interface IOptions

                                                                                                                                              interface IOptions {}

                                                                                                                                                index signature

                                                                                                                                                [index: string]: any;

                                                                                                                                                  interface ISecureFileOptions

                                                                                                                                                  interface ISecureFileOptions {}

                                                                                                                                                    property alg

                                                                                                                                                    alg?: string | undefined;

                                                                                                                                                      property secret

                                                                                                                                                      secret: string;

                                                                                                                                                        interface IStore

                                                                                                                                                        interface IStore {}

                                                                                                                                                          property type

                                                                                                                                                          type: string;

                                                                                                                                                            method clear

                                                                                                                                                            clear: (key: string) => boolean;

                                                                                                                                                              method get

                                                                                                                                                              get: (key: string) => any;

                                                                                                                                                                method merge

                                                                                                                                                                merge: (key: string, value: any) => boolean;

                                                                                                                                                                  method reset

                                                                                                                                                                  reset: (callback?: ICallbackFunction) => boolean;

                                                                                                                                                                    method set

                                                                                                                                                                    set: (key: string, value: any) => boolean;

                                                                                                                                                                      Package Files (1)

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

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