@depup/launchdarkly-node-server-sdk 7.0.4-depup.0

package/index.d.ts

@@ -0,0 +1,2426 @@
+// Type definitions for launchdarkly-node-server-sdk
+
+/**
+ * This is the API reference for the LaunchDarkly Server-Side SDK for Node.js.
+ *
+ * In typical usage, you will call [[init]] once at startup time to obtain an instance of
+ * [[LDClient]], which provides access to all of the SDK's functionality.
+ *
+ * For more information, see the [SDK reference guide](https://docs.launchdarkly.com/sdk/server-side/node-js).
+ */
+
+declare module 'launchdarkly-node-server-sdk' {
+  import { EventEmitter } from 'events';
+  import * as interfaces from 'launchdarkly-node-server-sdk/interfaces';
+
+  namespace errors {
+    export const LDPollingError: ErrorConstructor;
+    export const LDStreamingError: ErrorConstructor;
+    export const LDClientError: ErrorConstructor;
+    export const LDUnexpectedResponseError: ErrorConstructor;
+    export const LDInvalidSDKKeyError: ErrorConstructor;
+  }
+
+  /**
+   * Creates an instance of the LaunchDarkly client.
+   *
+   * Applications should instantiate a single instance for the lifetime of the application.
+   * The client will begin attempting to connect to LaunchDarkly as soon as it is created. To
+   * determine when it is ready to use, call [[LDClient.waitForInitialization]], or register an
+   * event listener for the `"ready"` event using [[LDClient.on]].
+   *
+   * **Important:** Do **not** try to instantiate `LDClient` with its constructor (`new LDClient()`); the SDK
+   * does not currently support this.
+   *
+   * @param key
+   *   The SDK key.
+   * @param options
+   *   Optional configuration settings.
+   * @return
+   *   The new client instance.
+   */
+  export function init(key: string, options?: LDOptions): LDClient;
+
+  /**
+   * The types of values a feature flag can have.
+   *
+   * Flags can have any JSON-serializable value.
+   */
+  export type LDFlagValue = any;
+
+  /**
+   * A map of feature flags from their keys to their values.
+   */
+  export interface LDFlagSet {
+    [key: string]: LDFlagValue;
+  }
+
+  /**
+   * An object that contains the state of all feature flags, generated by [[LDClient.allFlagsState]].
+   */
+  export interface LDFlagsState {
+    /**
+     * True if this object contains a valid snapshot of feature flag state, or false if the
+     * state could not be computed (for instance, because the client was offline or there
+     * was no user).
+     */
+    valid: boolean;
+
+    /**
+     * Returns the value of an individual feature flag at the time the state was recorded.
+     * It will be null if the flag returned the default value, or if there was no such flag.
+     *
+     * @param key
+     *   The flag key.
+     */
+    getFlagValue(key: string): LDFlagValue;
+
+    /**
+     * Returns the evaluation reason for a feature flag at the time the state was recorded.
+     * It will be null if reasons were not recorded, or if there was no such flag.
+     *
+     * @param key
+     *   The flag key.
+     */
+    getFlagReason(key: string): LDEvaluationReason;
+
+    /**
+     * Returns a map of feature flag keys to values. If a flag would have evaluated to the
+     * default value, its value will be null.
+     *
+     * Do not use this method if you are passing data to the front end to "bootstrap" the
+     * JavaScript client. Instead, use [[toJSON]].
+     */
+    allValues(): LDFlagSet;
+
+    /**
+     * Returns a Javascript representation of the entire state map, in the format used by
+     * the Javascript SDK. Use this method if you are passing data to the front end in
+     * order to "bootstrap" the JavaScript client.
+     *
+     * Do not rely on the exact shape of this data, as it may change in future to support
+     * the needs of the JavaScript client.
+     */
+    toJSON(): object;
+  }
+
+  /**
+   * Describes the reason that a flag evaluation produced a particular value. This is
+   * part of the [[LDEvaluationDetail]] object returned by [[LDClient.variationDetail]].
+   */
+  export interface LDEvaluationReason {
+    /**
+     * The general category of the reason:
+     *
+     * - `'OFF'`: The flag was off and therefore returned its configured off value.
+     * - `'FALLTHROUGH'`: The flag was on but the context did not match any targets or rules.
+     * - `'TARGET_MATCH'`: The context key was specifically targeted for this flag.
+     * - `'RULE_MATCH'`: the context matched one of the flag's rules.
+     * - `'PREREQUISITE_FAILED'`: The flag was considered off because it had at least one
+     *   prerequisite flag that either was off or did not return the desired variation.
+     * - `'ERROR'`: The flag could not be evaluated, e.g. because it does not exist or due
+     *   to an unexpected error.
+     */
+    kind: string;
+
+    /**
+     * A further description of the error condition, if the kind was `'ERROR'`.
+     */
+    errorKind?: string;
+
+    /**
+     * The index of the matched rule (0 for the first), if the kind was `'RULE_MATCH'`.
+     */
+    ruleIndex?: number;
+
+    /**
+     * The unique identifier of the matched rule, if the kind was `'RULE_MATCH'`.
+     */
+    ruleId?: string;
+
+    /**
+     * The key of the failed prerequisite flag, if the kind was `'PREREQUISITE_FAILED'`.
+     */
+    prerequisiteKey?: string;
+
+    /**
+     * Whether the evaluation was part of an experiment.
+     *
+     * This is true if the evaluation resulted in an experiment rollout and served one of
+     * the variations in the experiment. Otherwise it is false or undefined.
+     */
+    inExperiment?: boolean;
+
+    /**
+     * Describes the validity of Big Segment information, if and only if the flag evaluation
+     * required querying at least one Big Segment.
+     *
+     * - `'HEALTHY'`: The Big Segment query involved in the flag evaluation was successful, and
+     *   the segment state is considered up to date.
+     * - `'STALE'`: The Big Segment query involved in the flag evaluation was successful, but
+     *   the segment state may not be up to date
+     * - `'NOT_CONFIGURED'`: Big Segments could not be queried for the flag evaluation because
+     *   the SDK configuration did not include a Big Segment store.
+     * - `'STORE_ERROR'`: The Big Segment query involved in the flag evaluation failed, for
+     *   instance due to a database error.
+     */
+    bigSegmentsStatus?: "HEALTHY" | "STALE" | "NOT_CONFIGURED" | "STORE_ERROR";
+  }
+
+  /**
+   * An object that combines the result of a feature flag evaluation with information about
+   * how it was calculated.
+   *
+   * This is the result of calling [[LDClient.variationDetail]].
+   *
+   * For more information, see the [SDK reference guide](https://docs.launchdarkly.com/sdk/features/evaluation-reasons#nodejs-server-side).
+   */
+  export interface LDEvaluationDetail {
+    /**
+     * The result of the flag evaluation. This will be either one of the flag's variations or
+     * the default value that was passed to [[LDClient.variationDetail]].
+     */
+    value: LDFlagValue;
+
+    /**
+     * The index of the returned value within the flag's list of variations, e.g. 0 for the
+     * first variation-- or `null` if the default value was returned.
+     */
+    variationIndex?: number;
+
+    /**
+     * An object describing the main factor that influenced the flag evaluation value.
+     */
+    reason: LDEvaluationReason;
+  }
+
+  /**
+   * LaunchDarkly initialization options.
+   */
+  export interface LDOptions {
+    /**
+     * The base URI for the LaunchDarkly server.
+     *
+     * Most users should use the default value.
+     */
+    baseUri?: string;
+
+    /**
+     * The base URI for the LaunchDarkly streaming server.
+     *
+     * Most users should use the default value.
+     */
+    streamUri?: string;
+
+    /**
+     * The base URI for the LaunchDarkly events server.
+     *
+     * Most users should use the default value.
+     */
+    eventsUri?: string;
+
+    /**
+     * The connection timeout, in seconds.
+     */
+    timeout?: number;
+
+    /**
+     * The capacity of the analytics events queue.
+     *
+     * The client buffers up to this many events in memory before flushing. If the capacity is
+     * exceeded before the buffer is flushed, events will be discarded.
+     */
+    capacity?: number;
+
+    /**
+     * Configures a logger for warnings and errors generated by the SDK.
+     *
+     * The logger can be any object that conforms to the [[LDLogger]] interface.
+     * For a simple implementation that lets you filter by log level, see
+     * [[basicLogger]]. You can also use an instance of `winston.Logger` from
+     * the Winston logging package.
+     *
+     * If you do not set this property, the SDK uses [[basicLogger]] with a
+     * minimum level of `info`.
+     */
+    logger?: LDLogger;
+
+    /**
+     * A component that stores feature flags and related data received from LaunchDarkly.
+     *
+     * By default, this is an in-memory data structure. Database integrations are also
+     * available, as described in the
+     * [SDK features guide](https://docs.launchdarkly.com/sdk/concepts/data-stores).
+     *
+     * Some implementations provide the store implementation object itself, while others
+     * provide a factory function that creates the store implementation based on the SDK
+     * configuration; this property accepts either.
+     */
+    featureStore?: LDFeatureStore | ((options: LDOptions) => LDFeatureStore);
+
+    /**
+     * Additional parameters for configuring the SDK's Big Segments behavior.
+     *
+     * Big Segments are a specific type of user segments. For more information, read the
+     * LaunchDarkly documentation: https://docs.launchdarkly.com/home/users/big-segments
+     *
+     * By default, there is no configuration and Big Segments cannot be evaluated. In this
+     * case, any flag evaluation that references a Big Segment will behave as if no users
+     * are included in any Big Segments, and the {@link LDEvaluationReason} associated with any
+     * such flag evaluation will have a `bigSegmentsStatus` of `"NOT_CONFIGURED"`.
+     */
+    bigSegments?: LDBigSegmentsOptions;
+
+    /**
+     * A component that obtains feature flag data and puts it in the feature store.
+     *
+     * By default, this is the client's default streaming or polling component. It can be changed
+     * for testing purposes; see [[FileDataSource]].
+     */
+    updateProcessor?: object;
+
+    /**
+     * The interval in between flushes of the analytics events queue, in seconds.
+     */
+    flushInterval?: number;
+
+    /**
+     * The time between polling requests, in seconds. Ignored in streaming mode.
+     */
+    pollInterval?: number;
+
+    /**
+     * Allows you to specify a host for an optional HTTP proxy.
+     */
+    proxyHost?: string;
+
+    /**
+     * Allows you to specify a port for an optional HTTP proxy.
+     *
+     * Both the host and port must be specified to enable proxy support.
+     */
+    proxyPort?: number;
+
+    /**
+     * When using an HTTP proxy, specifies whether it is accessed via `http` or `https`.
+     */
+    proxyScheme?: string;
+
+    /**
+     * Allows you to specify basic authentication parameters for an optional HTTP proxy.
+     * Usually of the form `username:password`.
+     */
+    proxyAuth?: string;
+
+    /**
+     * Whether the client should be initialized in offline mode.
+     */
+    offline?: boolean;
+
+    /**
+     * Whether streaming mode should be used to receive flag updates.
+     *
+     * This is true by default. If you set it to false, the client will use polling.
+     * Streaming should only be disabled on the advice of LaunchDarkly support.
+     */
+    stream?: boolean;
+
+    /**
+     * Sets the initial reconnect delay for the streaming connection, in seconds.
+     *
+     * The streaming service uses a backoff algorithm (with jitter) every time the connection needs
+     * to be reestablished. The delay for the first reconnection will start near this value, and then
+     * increase exponentially for any subsequent connection failures.
+     *
+     * The default value is 1.
+     */
+    streamInitialReconnectDelay?: number;
+
+    /**
+     * Whether you are using the LaunchDarkly Relay Proxy in daemon mode.
+     *
+     * In this configuration, the client will not connect to LaunchDarkly to get feature flags,
+     * but will instead get feature state from a database (Redis or another supported feature
+     * store integration) that is populated by the Relay Proxy. By default, this is false.
+     * To learn more, read [Using daemon mode](https://docs.launchdarkly.com/home/relay-proxy/using#using-daemon-mode).
+     */
+    useLdd?: boolean;
+
+    /**
+     * Whether to send analytics events back to LaunchDarkly. By default, this is true.
+     */
+    sendEvents?: boolean;
+
+    /**
+     * Whether all context attributes (except the contexy key) should be marked as private, and
+     * not sent to LaunchDarkly.
+     *
+     * By default, this is false.
+     */
+    allAttributesPrivate?: boolean;
+
+    /**
+     * The names of any context attributes that should be marked as private, and not sent
+     * to LaunchDarkly.
+     * 
+     * Any contexts sent to LaunchDarkly with this configuration active will have attributes with
+     * these names removed. This is in addition to any attributes that were marked as private for an
+     * individual context with {@link LDContextMeta.privateAttributes}. Setting 
+     * {@link LDOptions.allAttributesPrivate} to true overrides this.
+     * 
+     * If and only if a parameter starts with a slash, it is interpreted as a slash-delimited path
+     * that can denote a nested property within a JSON object. For instance, "/address/street" means
+     * that if there is an attribute called "address" that is a JSON object, and one of the object's
+     * properties is "street", the "street" property will be redacted from the analytics data but
+     * other properties within "address" will still be sent. This syntax also uses the JSON Pointer
+     * convention of escaping a literal slash character as "~1" and a tilde as "~0".
+     */
+    privateAttributes?: Array<string>;
+
+    /**
+     * The number of context keys that the event processor can remember at any one time,
+     * so that duplicate context details will not be sent in analytics events.
+     *
+     * Defaults to 1000.
+     */
+    contextKeysCapacity?: number;
+
+    /**
+     * The interval (in seconds) at which the event processor will reset its set of
+     * known context keys.
+     *
+     * Defaults to 300.
+     */
+    contextKeysFlushInterval?: number;
+
+    /**
+     * The number of user keys that the event processor can remember at any one time,
+     * so that duplicate user details will not be sent in analytics events.
+     *
+     * Defaults to 1000.
+     * 
+     * @deprecated Use contextKeysCapacity instead.
+     */
+    userKeysCapacity?: number;
+
+    /**
+     * The interval (in seconds) at which the event processor will reset its set of
+     * known user keys.
+     *
+     * Defaults to 300.
+     * 
+     * @deprecated Use contextKeysFlushInterval instead.
+     */
+    userKeysFlushInterval?: number;
+
+    /**
+     * Additional parameters to pass to the Node HTTPS API for secure requests.  These can include any
+     * of the TLS-related parameters supported by `https.request()`, such as `ca`, `cert`, and `key`.
+     *
+     * For more information, see the Node documentation for `https.request()` and `tls.connect()`.
+     */
+    tlsParams?: LDTLSOptions;
+
+    /**
+     * Set to true to opt out of sending diagnostics data.
+     *
+     * Unless the `diagnosticOptOut` field is set to true, the client will send some diagnostics data to the
+     * LaunchDarkly servers in order to assist in the development of future SDK improvements. These diagnostics
+     * consist of an initial payload containing some details of SDK in use, the SDK's configuration, and the platform
+     * the SDK is being run on, as well as payloads sent periodically with information on irregular occurrences such
+     * as dropped events.
+     */
+    diagnosticOptOut?: boolean;
+
+    /**
+     * The interval at which periodic diagnostic data is sent, in seconds.
+     *
+     * The default is 900 (every 15 minutes) and the minimum value is 60 (every minute).
+     */
+    diagnosticRecordingInterval?: number;
+
+    /**
+     * For use by wrapper libraries to set an identifying name for the wrapper being used.
+     *
+     * This will be sent in User-Agent headers during requests to the LaunchDarkly servers to allow recording
+     * metrics on the usage of these wrapper libraries.
+     */
+    wrapperName?: string;
+
+    /**
+     * For use by wrapper libraries to report the version of the library in use.
+     *
+     * If `wrapperName` is not set, this field will be ignored. Otherwise the version string will be included in
+     * the User-Agent headers along with the `wrapperName` during requests to the LaunchDarkly servers.
+     */
+    wrapperVersion?: string;
+
+    /**
+     * Information about the application where the LaunchDarkly SDK is running.
+     */
+    application?: {
+      /**
+       * A unique identifier representing the application where the LaunchDarkly SDK is running.
+       * 
+       * This can be specified as any string value as long as it only uses the following characters: ASCII letters,
+       * ASCII digits, period, hyphen, underscore. A string containing any other characters will be ignored.
+       * 
+       * Example: `authentication-service`
+       */
+      id?: string;
+
+      /**
+       * A unique identifier representing the version of the application where the LaunchDarkly SDK is running.
+       * 
+       * This can be specified as any string value as long as it only uses the following characters: ASCII letters,
+       * ASCII digits, period, hyphen, underscore. A string containing any other characters will be ignored.
+       * 
+       * Example: `1.0.0` (standard version string) or `abcdef` (sha prefix)
+       */
+      version?: string;
+    }
+  }
+
+  /**
+   * Additional parameters for configuring the SDK's Big Segments behavior.
+   *
+   * Big Segments are a specific type of user segments. For more information, read the LaunchDarkly
+   * documentation: https://docs.launchdarkly.com/home/users/big-segments
+   *
+   * @see {@link LDOptions.bigSegments}
+   */
+  export interface LDBigSegmentsOptions {
+    /**
+     * Specifies the storage component that provides Big Segments data.
+     *
+     * This property is mandatory. It must be obtained from one of the SDK's database integrations,
+     * such as https://github.com/launchdarkly/node-server-sdk-redis. You will normally specify a
+     * database implementation that matches how the LaunchDarkly Relay Proxy is configured, since the
+     * Relay Proxy manages the Big Segment data.
+     */
+    store: (options: LDOptions) => interfaces.BigSegmentStore;
+
+    /**
+     * The maximum number of users whose Big Segment state will be cached by the SDK at any given time.
+     *
+     * To reduce database traffic, the SDK maintains a least-recently-used cache by user key. When a feature
+     * flag that references a Big Segment is evaluated for some user who is not currently in the cache, the
+     * SDK queries the database for all Big Segment memberships of that user, and stores them together in a
+     * single cache entry. If the cache is full, the oldest entry is dropped.
+     *
+     * A higher value for `userCacheSize` means that database queries for Big Segments will be done
+     * less often for recently-referenced users, if the application has many users, at the cost of
+     * increased memory used by the cache.
+     *
+     * Cache entries can also expire based on the setting of {@link userCacheTime}.
+     *
+     * If not specified, the default value is 1000.
+     */
+    userCacheSize?: number;
+
+    /**
+     * The maximum length of time that the Big Segment state for a user will be cached by the SDK,
+     * in seconds.
+     *
+     * See {@link userCacheSize} for more about this cache. A higher value for `userCacheTime` means
+     * that database queries for the Big Segment state of any given user will be done less often, but
+     * that changes to segment membership may not be detected as soon.
+     *
+     * If not specified, the default value is 5. Negative values are changed to the default.
+     */
+    userCacheTime?: number;
+
+    /**
+     * The interval at which the SDK will poll the Big Segment store to make sure it is available
+     * and to determine how long ago it was updated, in seconds.
+     *
+     * If not specified, the default value is 5. Zero or negative values are changed to the default.
+     */
+    statusPollInterval?: number;
+
+    /**
+     * The maximum length of time between updates of the Big Segments data before the data is
+     * considered out of date, in seconds.
+     *
+     * Normally, the LaunchDarkly Relay Proxy updates a timestamp in the Big Segment store at intervals to
+     * confirm that it is still in sync with the LaunchDarkly data, even if there have been no changes to the
+     * If the timestamp falls behind the current time by the amount specified in `staleAfter`, the SDK
+     * assumes that something is not working correctly in this process and that the data may not be accurate.
+     *
+     * While in a stale state, the SDK will still continue using the last known data, but the status from
+     * {@link interfaces.BigSegmentStoreStatusProvider.getStatus} will have `stale: true`, and any
+     * {@link LDEvaluationReason} generated from a feature flag that references a Big Segment will have a
+     * `bigSegmentsStatus` of `"STALE"`.
+     *
+     * If not specified, the default value is 120 (two minutes). Zero or negative values are changed to
+     * the default.
+     */
+    staleAfter?: number;
+  }
+
+  /**
+   * Additional parameters to pass to the Node HTTPS API for secure requests.  These can include any
+   * of the TLS-related parameters supported by `https.request()`, such as `ca`, `cert`, and `key`.
+   *
+   * For more information, see the Node documentation for `https.request()` and `tls.connect()`.
+   */
+  export interface LDTLSOptions {
+    ca?: string | string[] | Buffer | Buffer[];
+    cert?: string | string[] | Buffer | Buffer[];
+    checkServerIdentity?: (servername: string, cert: any) => Error | undefined;
+    ciphers?: string;
+    pfx?: string | string[] | Buffer | Buffer[] | object[];
+    key?: string | string[] | Buffer | Buffer[] | object[];
+    passphrase?: string;
+    rejectUnauthorized?: boolean;
+    secureProtocol?: string;
+    servername?: string;
+  }
+
+  /**
+   * Meta attributes are used to control behavioral aspects of the Context.
+   * They cannot be addressed in targeting rules.
+   */
+  export interface LDContextMeta {
+    /**
+     * 
+     * Designate any number of Context attributes, or properties within them, as private: that is,
+     * their values will not be sent to LaunchDarkly.
+     * 
+     * Each parameter can be a simple attribute name, such as "email". Or, if the first character is
+     * a slash, the parameter is interpreted as a slash-delimited path to a property within a JSON
+     * object, where the first path component is a Context attribute name and each following
+     * component is a nested property name: for example, suppose the attribute "address" had the
+     * following JSON object value:
+     * 
+     * ```
+     * 	{"street": {"line1": "abc", "line2": "def"}}
+     * ```
+     * 
+     * Using ["/address/street/line1"] in this case would cause the "line1" property to be marked as
+     * private. This syntax deliberately resembles JSON Pointer, but other JSON Pointer features
+     * such as array indexing are not supported for Private.
+     * 
+     * This action only affects analytics events that involve this particular Context. To mark some
+     * (or all) Context attributes as private for all users, use the overall configuration for the
+     * SDK.
+     * See {@link LDOptions.allAttributesPrivate} and {@link LDOptions.privateAttributes}.
+     * 
+     * The attributes "kind" and "key", and the "_meta" attributes cannot be made private.
+     * 
+     * In this example, firstName is marked as private, but lastName is not:
+     * 
+     * ```
+     * const context = {
+     *   kind: 'org',
+     *   key: 'my-key',
+     *   firstName: 'Pierre',
+     *   lastName: 'Menard',
+     *   _meta: {
+     *     privateAttributes: ['firstName'], 
+     *   }
+     * };
+     * ```
+     * 
+     * This is a metadata property, rather than an attribute that can be addressed in evaluations:
+     * that is, a rule clause that references the attribute name "privateAttributes", will not use
+     * this value, but would use a "privateAttributes" attribute set on the context.
+     */
+    privateAttributes?: string[];
+  }
+
+  interface LDContextCommon {
+    /**
+     * If true, the context will _not_ appear on the Contexts page in the LaunchDarkly dashboard.
+     */
+    anonymous?: boolean;
+
+    /**
+     * A unique string identifying a context.
+     */
+    key: string;
+
+    /**
+     * The context's name.
+     *
+     * You can search for contexts on the Contexts page by name.
+     */
+    name?: string;
+
+    /**
+     * Meta attributes are used to control behavioral aspects of the Context, such as private
+     * private attributes. See {@link LDContextMeta.privateAttributes} as an example.
+     *
+     * They cannot be addressed in targeting rules.
+     */
+    _meta?: LDContextMeta;
+
+    /**
+     * Any additional attributes associated with the context.
+     */
+    [attribute: string]: any;
+  }
+
+
+  /**
+   * A context which represents a single kind.
+   * 
+   * For a single kind context the 'kind' may not be 'multi'.
+   * 
+   * ```
+   * const myOrgContext = {
+   *   kind: 'org',
+   *   key: 'my-org-key',
+   *   someAttribute: 'my-attribute-value'
+   * };
+   * ```
+   * 
+   * The above context would be a single kind context representing an organization. It has a key
+   * for that organization, and a single attribute 'someAttribute'.
+   */
+  interface LDSingleKindContext extends LDContextCommon {
+    /**
+     * The kind of the context.
+     */
+    kind: string;
+  }
+
+  /**
+   * A context which represents multiple kinds. Each kind having its own key and attributes.
+   * 
+   * A multi-context must contain `kind: 'multi'` at the root.
+   * 
+   * ```
+   * const myMultiContext = {
+   *   // Multi-contexts must be of kind 'multi'.
+   *   kind: 'multi',
+   *   // The context is namespaced by its kind. This is an 'org' kind context.
+   *   org: {
+   *     // Each component context has its own key and attributes.
+   *     key: 'my-org-key',
+   *     someAttribute: 'my-attribute-value',
+   *   },
+   *   user: {
+   *     key: 'my-user-key',
+   *     firstName: 'Bob',
+   *     lastName: 'Bobberson',
+   *     _meta: {
+   *       // Each component context has its own _meta attributes. This will only apply the this
+   *       // 'user' context.
+   *       privateAttributes: ['firstName']
+   *     }
+   *   }
+   * };
+   * ```
+   * 
+   * The above multi-context contains both an 'org' and a 'user'. Each with their own key,
+   * attributes, and _meta attributes.
+   */
+  interface LDMultiKindContext {
+    /**
+     * The kind of the context.
+     */
+    kind: "multi",
+
+    /**
+     * The contexts which compose this multi-kind context.
+     * 
+     * These should be of type LDContextCommon. "multi" is to allow
+     * for the top level "kind" attribute.
+     */
+    [kind: string]: "multi" | LDContextCommon;
+  }
+
+  /**
+   * A LaunchDarkly context object.
+   */
+  export type LDContext = LDUser | LDSingleKindContext | LDMultiKindContext;
+
+  /**
+   * A legacy LaunchDarkly user object.
+   * 
+   * This type exists for easing migration to contexts, but code should be moved to use single/multi
+   * contexts.
+   *
+   * The LDUser object is currently supported for ease of upgrade. It may be removed in a future
+   * release.
+   * In order to convert an LDUser into a LDSingleKindContext the following changes should
+   * be made.
+   * 
+   * 1.) Add a kind to the object. `kind: 'user'`.
+   * 
+   * 2.) Move custom attributes to the top level of the object.
+   * 
+   * 3.) Move `privateAttributeNames` to `_meta.privateAttributes`.
+   * 
+   * ```
+   * const LDUser: user = {
+   *   key: '1234',
+   *   privateAttributeNames: ['myAttr']
+   *   custom: {
+   *     myAttr: 'value'
+   *   }
+   * }
+   * 
+   * const LDSingleKindContext: context = {
+   *   kind: 'user',
+   *   key: '1234',
+   *   myAttr: 'value'
+   *   _meta: {
+   *     privateAttributes: ['myAttr']
+   *   }
+   * }
+   * ```
+   */
+  export interface LDUser {
+    /**
+     * A unique string identifying a user.
+     */
+    key: string;
+
+    /**
+     * The user's name.
+     *
+     * You can search for users on the User page by name.
+     */
+    name?: string;
+
+    /**
+     * The user's first name.
+     */
+    firstName?: string;
+
+    /**
+     * The user's last name.
+     */
+    lastName?: string;
+
+    /**
+     * The user's email address.
+     *
+     * If an `avatar` URL is not provided, LaunchDarkly will use Gravatar
+     * to try to display an avatar for the user on the Users page.
+     */
+    email?: string;
+
+    /**
+     * An absolute URL to an avatar image for the user.
+     */
+    avatar?: string;
+
+    /**
+     * The user's IP address.
+     *
+     * If you provide an IP, LaunchDarkly will use a geolocation service to
+     * automatically infer a `country` for the user, unless you've already
+     * specified one.
+     */
+    ip?: string;
+
+    /**
+     * The country associated with the user.
+     */
+    country?: string;
+
+    /**
+     * If true, the user will _not_ appear on the Users page in the LaunchDarkly dashboard.
+     */
+    anonymous?: boolean;
+
+    /**
+     * Any additional attributes associated with the user.
+     */
+    custom?: {
+      [key: string]:
+      | string
+      | boolean
+      | number
+      | Array<string | boolean | number>;
+    };
+
+    /**
+     * Specifies a list of attribute names (either built-in or custom) which should be
+     * marked as private, and not sent to LaunchDarkly in analytics events. This is in
+     * addition to any private attributes designated in the global configuration
+     * with [[LDOptions.privateAttributeNames]] or [[LDOptions.allAttributesPrivate]].
+     */
+    privateAttributeNames?: Array<string>;
+  }
+
+  /**
+   * The LaunchDarkly client logger interface.
+   *
+   * The [[LDOptions.logger]] property accepts any object that conforms to this
+   * interface. The SDK only uses four logging levels: `error`, `warn`, `info`, and
+   * `debug`. It will call the corresponding method of the `LDLogger` either with a
+   * single string argument, or with a format string and variable arguments in the
+   * format used by Node's `util.format()`.
+   *
+   * The [Winston](https://github.com/winstonjs/winston) logging package provides a
+   * logger that conforms to this interface, so if you have created a logger with
+   * Winston, you can simply put it into the [[LDOptions.logger]] property.
+   *
+   * If you do not provide a logger object, the SDK uses the [[basicLogger]]
+   * implementation with a minimum level of `info`.
+   */
+  export interface LDLogger {
+    /**
+     * The error logger.
+     *
+     * @param args
+     *   A sequence of any JavaScript values.
+     */
+    error(...args: any[]): void;
+
+    /**
+     * The warning logger.
+     *
+     * @param args
+     *   A sequence of any JavaScript values.
+     */
+    warn(...args: any[]): void;
+
+    /**
+     * The info logger.
+     *
+     * @param args
+     *   A sequence of any JavaScript values.
+     */
+    info(...args: any[]): void;
+
+    /**
+     * The debug logger.
+     *
+     * @param args
+     *   A sequence of any JavaScript values.
+     */
+    debug(...args: any[]): void;
+  }
+
+  /**
+   * Interface for a feature store component.
+   *
+   * The feature store is what the client uses to store feature flag data that has been received
+   * from LaunchDarkly. By default, it uses an in-memory implementation; database integrations are
+   * also available. Read the [SDK features guide](https://docs.launchdarkly.com/sdk/concepts/data-stores).
+   * You will not need to use this interface unless you are writing your own implementation.
+   *
+   * Feature store methods can and should call their callbacks directly whenever possible, rather
+   * than deferring them with setImmediate() or process.nextTick(). This means that if for any
+   * reason you are updating or querying a feature store directly in your application code (which
+   * is not part of normal use of the SDK) you should be aware that the callback may be executed
+   * immediately.
+   */
+  export interface LDFeatureStore {
+    /**
+     * Get an entity from the store.
+     *
+     * The store should treat any entity with the property `deleted: true` as "not found".
+     *
+     * @param kind
+     *   The type of data to be accessed. The store should not make any assumptions about the format
+     *   of the data, but just return a JSON object. The actual type of this parameter is
+     *   [[interfaces.DataKind]].
+     *
+     * @param key
+     *   The unique key of the entity within the specified collection.
+     *
+     * @param callback
+     *   Will be called with the retrieved entity, or null if not found. The actual type of the result
+     *   value is [[interfaces.VersionedData]].
+     */
+    get(kind: object, key: string, callback: (res: object) => void): void;
+
+    /**
+     * Get all entities from a collection.
+     *
+     * The store should filter out any entities with the property `deleted: true`.
+     *
+     * @param kind
+     *   The type of data to be accessed. The store should not make any assumptions about the format
+     *   of the data, but just return an object in which each key is the `key` property of an entity
+     *   and the value is the entity. The actual type of this parameter is [[interfaces.DataKind]].
+     *
+     * @param callback
+     *   Will be called with the resulting map. The actual type of the result value is
+     *   `interfaces.KeyedItems<VersionedData>`.
+     */
+    all(kind: object, callback: (res: object) => void): void;
+
+    /**
+     * Initialize the store, overwriting any existing data.
+     *
+     * @param allData
+     *   An object in which each key is the "namespace" of a collection (e.g. `"features"`) and
+     *   the value is an object that maps keys to entities. The actual type of this parameter is
+     *   `interfaces.FullDataSet<VersionedData>`.
+     *
+     * @param callback
+     *   Will be called when the store has been initialized.
+     */
+    init(allData: object, callback: () => void): void;
+
+    /**
+     * Delete an entity from the store.
+     *
+     * Deletion should be implemented by storing a placeholder object with the property
+     * `deleted: true` and a `version` property equal to the provided version. In other words,
+     * it should be exactly the same as calling `upsert` with such an object.
+     *
+     * @param kind
+     *   The type of data to be accessed. The actual type of this parameter is
+     *   [[interfaces.DataKind]].
+     *
+     * @param key
+     *   The unique key of the entity within the specified collection.
+     *
+     * @param version
+     *   A number that must be greater than the `version` property of the existing entity in
+     *   order for it to be deleted. If it is less than or equal to the existing version, the
+     *   method should do nothing.
+     *
+     * @param callback
+     *   Will be called when the delete operation is complete.
+     */
+    delete(kind: object, key: string, version: string, callback: () => void): void;
+
+    /**
+     * Add an entity or update an existing entity.
+     *
+     * @param kind
+     *   The type of data to be accessed. The actual type of this parameter is
+     *   [[interfaces.DataKind]].
+     *
+     * @param data
+     *   The contents of the entity, as an object that can be converted to JSON. The store
+     *   should check the `version` property of this object, and should *not* overwrite any
+     *   existing data if the existing `version` is greater than or equal to that value.
+     *   The actual type of this parameter is [[interfaces.VersionedData]].
+     *
+     * @param callback
+     *   Will be called after the upsert operation is complete.
+     */
+    upsert(kind: object, data: object, callback: () => void): void;
+
+    /**
+     * Tests whether the store is initialized.
+     *
+     * "Initialized" means that the store has been populated with data, either by the client
+     * having called `init()` within this process, or by another process (if this is a shared
+     * database).
+     *
+     * @param callback
+     *   Will be called back with the boolean result.
+     */
+    initialized(callback: (isInitialized: boolean) => void): void;
+
+    /**
+     * Releases any resources being used by the feature store.
+     */
+    close(): void;
+  }
+
+  /**
+   * The LaunchDarkly client stream processor
+   *
+   * The client uses this internally to retrieve updates from LaunchDarkly.
+   *
+   * @ignore
+   */
+  export interface LDStreamProcessor {
+    start: (fn?: (err?: any) => void) => void;
+    stop: () => void;
+    close: () => void;
+  }
+
+  /**
+   * The LaunchDarkly client feature flag requestor
+   *
+   * The client uses this internally to retrieve feature flags from LaunchDarkly.
+   *
+   * @ignore
+   */
+  export interface LDFeatureRequestor {
+    requestObject: (
+      kind: any,
+      key: string,
+      cb: (err: any, body: any) => void
+    ) => void;
+    requestAllData: (cb: (err: any, body: any) => void) => void;
+  }
+
+  /**
+   * Optional settings that can be passed to [[LDClient.allFlagsState]].
+   */
+  export interface LDFlagsStateOptions {
+    /**
+     * True if the state should include only flags that have been marked for use with the
+     * client-side SDK. By default, all flags are included.
+     */
+    clientSideOnly?: boolean;
+    /**
+     * True if evaluation reason data should be captured in the state object (see LDClient.variationDetail).
+     * By default, it is not.
+     */
+    withReasons?: boolean;
+    /**
+     * True if any flag metadata that is normally only used for event generation-- such as flag versions and
+     * evaluation reasons-- should be omitted for any flag that does not have event tracking or debugging turned on.
+     * This reduces the size of the JSON data if you are passing the flag state to the front end.
+     */
+    detailsOnlyForTrackedFlags?: boolean;
+  }
+
+  /**
+   * The LaunchDarkly SDK client object.
+   *
+   * Create this object with [[init]]. Applications should configure the client at startup time and continue
+   * to use it throughout the lifetime of the application, rather than creating instances on the fly.
+   *
+   * Note that `LDClient` inherits from `EventEmitter`, so you can use the standard `on()`, `once()`, and
+   * `off()` methods to receive events. The standard `EventEmitter` methods are not documented here; see the
+   * {@link https://nodejs.org/api/events.html#events_class_eventemitter|Node API documentation}. For a
+   * description of events you can listen for, see [[on]].
+   *
+   * @see {@link https://docs.launchdarkly.com/sdk/server-side/node-js|SDK Reference Guide}
+   */
+  export interface LDClient extends EventEmitter {
+    /**
+     * Tests whether the client has completed initialization.
+     *
+     * If this returns false, it means that the client has not yet successfully connected to LaunchDarkly.
+     * It might still be in the process of starting up, or it might be attempting to reconnect after an
+     * unsuccessful attempt, or it might have received an unrecoverable error (such as an invalid SDK key)
+     * and given up.
+     *
+     * @returns
+     *   True if the client has successfully initialized.
+     */
+    initialized(): boolean;
+
+    /**
+     * Returns a Promise that tracks the client's initialization state.
+     *
+     * The Promise will be resolved if the client successfully initializes, or rejected if client
+     * initialization has failed unrecoverably (for instance, if it detects that the SDK key is invalid).
+     * Keep in mind that unhandled Promise rejections can be fatal in Node, so if you call this method,
+     * be sure to attach a rejection handler to it (or, if using `async`/`await`, a catch block).
+     *
+     * Note that you can also use event listeners ([[on]]) for the same purpose: the event `"ready"`
+     * indicates success, and `"failed"` indicates failure.
+     *
+     * There is no built-in timeout for this method. If you want your code to stop waiting on the
+     * Promise after some amount of time, you could use
+     * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/race|`Promise.race()`}
+     * or one of the several NPM helper packages that provides a standard mechanism for this. Regardless
+     * of whether you continue to wait, the SDK will still retry all connection failures indefinitely
+     * unless it gets an unrecoverable error as described above.
+     *
+     * @returns
+     *   A Promise that will be resolved if the client initializes successfully, or rejected if it
+     *   fails. If successful, the result is the same client object.
+     *
+     * @example
+     * This example shows use of Promise chaining methods for specifying handlers:
+     * ```javascript
+     *   client.waitForInitialization().then(() => {
+     *     // do whatever is appropriate if initialization has succeeded
+     *   }).catch(err => {
+     *     // do whatever is appropriate if initialization has failed
+     *   })
+     * ```
+     *
+     * @example
+     * This example shows use of `async`/`await` syntax for specifying handlers:
+     * ```javascript
+     *   try {
+     *     await client.waitForInitialization();
+     *     // do whatever is appropriate if initialization has succeeded
+     *   } catch (err) {
+     *     // do whatever is appropriate if initialization has failed
+     *   }
+     * ```
+     */
+    waitForInitialization(): Promise<LDClient>;
+
+    /**
+     * Determines the variation of a feature flag for a context.
+     *
+     * @param key
+     *   The unique key of the feature flag.
+     * @param context
+     *   The context requesting the flag. The client will generate an analytics event to register
+     *   this context with LaunchDarkly if the context does not already exist.
+     * @param defaultValue
+     *   The default value of the flag, to be used if the value is not available from LaunchDarkly.
+     * @param callback
+     *   A Node-style callback to receive the result value. If omitted, you will receive a Promise instead.
+     * @returns
+     *   If you provided a callback, then nothing. Otherwise, a Promise which will be resolved
+     *   with the result value.
+     */
+    variation(
+      key: string,
+      context: LDContext,
+      defaultValue: LDFlagValue,
+      callback?: (err: any, res: LDFlagValue) => void
+    ): Promise<LDFlagValue>;
+
+    /**
+     * Determines the variation of a feature flag for a context, along with information about how it was
+     * calculated.
+     *
+     * The `reason` property of the result will also be included in analytics events, if you are
+     * capturing detailed event data for this flag.
+     *
+     * For more information, see the [SDK reference guide](https://docs.launchdarkly.com/sdk/features/evaluation-reasons#nodejs-server-side).
+     *
+     * @param key
+     *   The unique key of the feature flag.
+     * @param context
+     *   The context requesting the flag. The client will generate an analytics event to register
+     *   this context with LaunchDarkly if the context does not already exist.
+     * @param defaultValue
+     *   The default value of the flag, to be used if the value is not available from LaunchDarkly.
+     * @param callback
+     *   A Node-style callback to receive the result (as an [[LDEvaluationDetail]]). If omitted, you
+     *   will receive a Promise instead.
+     * @returns
+     *   If you provided a callback, then nothing. Otherwise, a Promise which will be resolved
+     *   with the result (as an [[LDEvaluationDetail]]).
+     */
+    variationDetail(
+      key: string,
+      context: LDContext,
+      defaultValue: LDFlagValue,
+      callback?: (err: any, res: LDEvaluationDetail) => void
+    ): Promise<LDEvaluationDetail>;
+
+    /**
+     * Builds an object that encapsulates the state of all feature flags for a given context.
+     * This includes the flag values and also metadata that can be used on the front end. This
+     * method does not send analytics events back to LaunchDarkly.
+     *
+     * The most common use case for this method is to bootstrap a set of client-side
+     * feature flags from a back-end service. Call the `toJSON()` method of the returned object
+     * to convert it to the data structure used by the client-side SDK.
+     *
+     * @param context
+     *   The context requesting the feature flags.
+     * @param options
+     *   Optional [[LDFlagsStateOptions]] to determine how the state is computed.
+     * @param callback
+     *   A Node-style callback to receive the result (as an [[LDFlagsState]]). If omitted, you
+     *   will receive a Promise instead.
+     * @returns
+     *   If you provided a callback, then nothing. Otherwise, a Promise which will be resolved
+     *   with the result as an [[LDFlagsState]].
+     */
+    allFlagsState(
+      context: LDContext,
+      options?: LDFlagsStateOptions,
+      callback?: (err: Error, res: LDFlagsState) => void
+    ): Promise<LDFlagsState>;
+
+    /**
+     * Computes an HMAC signature of a context signed with the client's SDK key.
+     *
+     * For more information, see the JavaScript SDK Reference Guide on
+     * [Secure mode](https://github.com/launchdarkly/js-client#secure-mode).
+     *
+     * @param context
+     *   The context properties.
+     *
+     * @returns
+     *   The hash string.
+     */
+    secureModeHash(context: LDContext): string;
+
+    /**
+     * Discards all network connections, background tasks, and other resources held by the client.
+     *
+     * Do not attempt to use the client after calling this method.
+     */
+    close(): void;
+
+    /**
+     * Tests whether the client is configured in offline mode.
+     *
+     * @returns
+     *   True if the `offline` property is true in your [[LDOptions]].
+     */
+    isOffline(): boolean;
+
+    /**
+     * Tracks that a context performed an event.
+     *
+     * LaunchDarkly automatically tracks pageviews and clicks that are specified in the Metrics
+     * section of the dashboard. This can be used to track custom metrics (goals) or other events that do
+     * not currently have metrics.
+     *
+     * Note that event delivery is asynchronous, so the event may not actually be sent until later;
+     * see [[flush]].
+     *
+     * If the context is omitted or has no key, the client will log a warning and will not send an event.
+     *
+     * @param key
+     *   The name of the event, which may correspond to a metric in experiments.
+     * @param context
+     *   The context to track.
+     * @param data
+     *   Optional additional information to associate with the event.
+     * @param metricValue
+     *   A numeric value used by the LaunchDarkly experimentation feature in numeric custom metrics. Can
+     *   be omitted if this event is used by only non-numeric metrics. This field will also be returned
+     *   as part of the custom event for Data Export.
+     */
+    track(key: string, context: LDContext, data?: any, metricValue?: number): void;
+
+    /**
+     * Identifies a context to LaunchDarkly.
+     *
+     * This simply creates an analytics event that will transmit the given user properties to
+     * LaunchDarkly, so that the context will be visible on your dashboard even if you have not
+     * evaluated any flags for that user. It has no other effect.
+     *
+     * If the context is omitted or has no key, the client will log a warning
+     * and will not send an event.
+     *
+     * @param context
+     *   The context properties. Must contain at least the `key` property.
+     */
+    identify(context: LDContext): void;
+
+    /**
+     * Flushes all pending analytics events.
+     *
+     * Normally, batches of events are delivered in the background at intervals determined by the
+     * `flushInterval` property of [[LDOptions]]. Calling `flush()` triggers an immediate delivery.
+     * However, like Node I/O in general, this is still an asynchronous operation so you must still
+     * use Promise chaining, a callback, or `async`/`await` to detect when it has finished or failed.
+     *
+     * @param callback
+     *   A function which will be called when the flush completes (meaning that all pending events
+     *   have been delivered to LaunchDarkly). If omitted, you will receive a Promise instead.
+     *
+     * @returns
+     *   If you provided a callback, then nothing. Otherwise, a Promise which resolves once
+     *   flushing is finished. Note that the Promise will be rejected if the HTTP request
+     *   fails, so be sure to attach a rejection handler to it.
+     */
+    flush(callback?: (err: Error, res: boolean) => void): Promise<void>;
+
+    /**
+     * A mechanism for tracking the status of a Big Segment store.
+     *
+     * This object has methods for checking whether the Big Segment store is (as far as the SDK
+     * knows) currently operational and tracking changes in this status. See
+     * {@link interfaces.BigSegmentStoreStatusProvider} for more about this functionality.
+     */
+    readonly bigSegmentStoreStatusProvider: interfaces.BigSegmentStoreStatusProvider;
+
+    /**
+     * Registers an event listener that will be called when the client triggers some type of event.
+     *
+     * This is the standard `on` method inherited from Node's `EventEmitter`; see the
+     * {@link https://nodejs.org/api/events.html#events_class_eventemitter|Node API docs} for more
+     * details on how to manage event listeners. Here is a description of the event types defined
+     * by `LDClient`.
+     *
+     * - `"ready"`: Sent only once, when the client has successfully connected to LaunchDarkly.
+     * Alternately, you can detect this with [[waitForInitialization]].
+     * - `"failed"`: Sent only once, if the client has permanently failed to connect to LaunchDarkly.
+     * Alternately, you can detect this with [[waitForInitialization]].
+     * - `"error"`: Contains an error object describing some abnormal condition that the client has detected
+     * (such as a network error).
+     * - `"update"`: The client has received a change to a feature flag. The event parameter is an object
+     * containing a single property, `key`, the flag key. Note that this does not necessarily mean the flag's
+     * value has changed for any particular context, only that some part of the flag configuration was changed.
+     * - `"update:KEY"`: The client has received a change to the feature flag whose key is KEY. This is the
+     * same as `"update"` but allows you to listen for a specific flag.
+     *
+     * @param event the name of the event to listen for
+     * @param listener the function to call when the event happens
+     */
+    on(event: string | symbol, listener: (...args: any[]) => void): this;
+
+    // The following are symbols that LDClient inherits from EventEmitter, which we are declaring
+    // again here only so that we can use @ignore to exclude them from the generated docs.
+    // Unfortunately it does not seem possible to exclude these inherited methods en masse without
+    // using a Typedoc plugin.
+
+    /** @ignore */ addListener(event: string | symbol, listener: (...args: any[]) => void): this;
+    /** @ignore */ emit(event: string | symbol, ...args: any[]): boolean;
+    /** @ignore */ eventNames(): Array<string | symbol>;
+    /** @ignore */ getMaxListeners(): number;
+    /** @ignore */ listenerCount(type: string | symbol): number;
+    /** @ignore */ listeners(event: string | symbol): Function[];
+    /** @ignore */ prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
+    /** @ignore */ prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
+    /** @ignore */ rawListeners(event: string | symbol): Function[];
+    /** @ignore */ removeAllListeners(event?: string | symbol): this;
+    /** @ignore */ removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
+    /** @ignore */ setMaxListeners(n: number): this;
+    /** @ignore */ once(event: string | symbol, listener: (...args: any[]) => void): this;
+    /** @ignore */ off(event: string | symbol, listener: (...args: any[]) => void): this;
+  }
+
+  /**
+   * Provides a simple [[LDLogger]] implementation.
+   *
+   * This logging implementation uses a simple format that includes only the log level
+   * and the message text. Output is written to the standard error stream (`console.error`).
+   * You can filter by log level as described in [[BasicLoggerOptions.level]].
+   *
+   * To use the logger created by this function, put it into [[LDOptions.logger]]. If
+   * you do not set [[LDOptions.logger]] to anything, the SDK uses a default logger
+   * that is equivalent to `ld.basicLogger({ level: 'info' })`.
+   *
+   * @param options Configuration for the logger. If no options are specified, the
+   *   logger uses `{ level: 'info' }`.
+   *
+   * @example
+   * This example shows how to use `basicLogger` in your SDK options to enable console
+   * logging only at `warn` and `error` levels.
+   * ```javascript
+   *   const ldOptions = {
+   *     logger: ld.basicLogger({ level: 'warn' }),
+   *   };
+   * ```
+   *
+   * @example
+   * This example shows how to use `basicLogger` in your SDK options to cause log
+   * output to go to `console.log` instead of `console.error`.
+   * ```javascript
+   *   const ldOptions = {
+   *     logger: ld.basicLogger({ destination: console.log }),
+   *   };
+   * ```
+   */
+  export function basicLogger(
+    options?: BasicLoggerOptions
+  ): LDLogger;
+
+  /**
+   * Configuration for [[basicLogger]].
+   */
+  export interface BasicLoggerOptions {
+    /**
+     * The lowest level of log message to enable.
+     *
+     * See [[LDLogLevel]] for a list of possible levels. Setting a level here causes
+     * all lower-importance levels to be disabled: for instance, if you specify
+     * `'warn'`, then `'debug'` and `'info'` are disabled.
+     *
+     * If not specified, the default is `'info'` (meaning that `'debug'` is disabled).
+     */
+    level?: LDLogLevel;
+
+    /**
+     * An optional function to use to print each log line.
+     *
+     * If this is specified, `basicLogger` calls it to write each line of output. The
+     * argument is a fully formatted log line, not including a linefeed. The function
+     * is only called for log levels that are enabled.
+     *
+     * If not specified, the default is `console.error`.
+     *
+     * Setting this property to anything other than a function will cause SDK
+     * initialization to fail.
+     */
+    destination?: (line: string) => void,
+  }
+
+  /**
+   * Logging levels that can be used with [[basicLogger]].
+   *
+   * Set [[BasicLoggerOptions.level]] to one of these values to control what levels
+   * of log messages are enabled. Going from lowest importance (and most verbose)
+   * to most importance, the levels are `'debug'`, `'info'`, `'warn'`, and `'error'`.
+   * You can also specify `'none'` instead to disable all logging.
+   */
+  export type LDLogLevel = 'debug' | 'info' | 'warn' | 'error' | 'none';
+
+  /**
+   * Configuration for [[FileDataSource]].
+   * 
+   * @deprecated Import this type from the `launchdarkly-node-server-sdk/integrations` module instead.
+   *   It will be removed from the main SDK module in a future release.
+   */
+  export interface FileDataSourceOptions {
+    paths: Array<string>;
+    autoUpdate?: boolean;
+    logger?: LDLogger | object;
+  }
+
+  /**
+   * Creates an object that allows you to use local files as a source of feature flag state,
+   * instead of connecting to LaunchDarkly. This would typically be used in a test environment.
+   *
+   * @deprecated Import this function from the `launchdarkly-node-server-sdk/integrations` module instead.
+   *   It will be removed from the main SDK module in a future release.
+   */
+  export function FileDataSource(
+    options: FileDataSourceOptions
+  ): object;
+}
+
+/**
+ * This module contains tools for connecting the LaunchDarkly client to other software, or
+ * to test fixtures.
+ */
+declare module 'launchdarkly-node-server-sdk/integrations' {
+  import { LDLogger } from 'launchdarkly-node-server-sdk';
+
+  /**
+   * Configuration for [[FileDataSource]].
+   */
+  export interface FileDataSourceOptions {
+    /**
+     * The path(s) of the file(s) that FileDataSource will read.
+     */
+    paths: Array<string>;
+
+    /**
+     * True if FileDataSource should reload flags whenever one of the data files is modified.
+     * This feature uses Node's `fs.watch()` API, so it is subject to
+     * the limitations described [here](https://nodejs.org/docs/latest/api/fs.html#fs_fs_watch_filename_options_listener).
+     */
+    autoUpdate?: boolean;
+
+    /**
+     * Configures a logger for warnings and errors. This can be a custom logger or an instance of
+     * `winston.Logger`. By default, it uses the same logger as the rest of the SDK.
+     */
+    logger?: LDLogger | object;
+  }
+
+  /**
+   * Creates an object that allows you to use local files as a source of feature flag state,
+   * instead of connecting to LaunchDarkly. This would typically be used in a test environment.
+   *
+   * For more information about this feature, see the
+   * [SDK features guide](https://docs.launchdarkly.com/sdk/features/flags-from-files#nodejs-server-side).
+   *
+   * To use this component, call `FileDataSource(options)` and store the result in the `updateProcessor`
+   * property of your LaunchDarkly client configuration:
+   *
+   *     const { FileDataSource } = require('launchdarkly-node-server-sdk/integrations');
+   * 
+   *     const dataSource = FileDataSource({ paths: [ myFilePath ] });
+   *     const config = { updateProcessor: dataSource };
+   *
+   * This will cause the client not to connect to LaunchDarkly to get feature flags, and use
+   * the file data instead.
+   *
+   * The client may still make network connections to send analytics events, unless you have
+   * disabled this in your configuration by setting [[LDOptions.sendEvents]] to `false`.
+   *
+   * The supported file formats are as follows:
+   *
+   * - JSON files in the format described in the
+   *   [SDK features guide](https://docs.launchdarkly.com/sdk/features/flags-from-files#nodejs-server-side)
+   *   are always supported.
+   * - The SDK can also read YAML files with an equivalent schema, if you explicitly install
+   *   the [`yaml`](https://www.npmjs.com/package/yaml) package in your application. This
+   *   package is not installed by default, to avoid adding to the size of the SDK bundle
+   *   for this rarely-used feature. The SDK is compatible with any version of the package
+   *   that supports calling `yaml.parse(string)` with no custom options.
+   *
+   * @param options
+   *   Configuration for the data source. You should at least set the `paths` property.
+   * @returns
+   *   An object to put in the `updateProcessor` property for [[LDOptions]].
+   */
+  export function FileDataSource(
+    options: FileDataSourceOptions
+  ): object;
+
+  /**
+   * A mechanism for providing dynamically updatable feature flag state in a simplified form to
+   * an SDK client in test scenarios.
+   * 
+   * This function constructs a new [[TestData]] object. See [[TestData]] for usage details.
+   *
+   * @example
+   *     const { TestData } = require('launchdarkly-node-server-sdk/interfaces');
+   * 
+   *     const td = TestData();
+   *     testData.update(td.flag("flag-key-1").booleanFlag().variationForAll(true));
+   *     const client = new LDClient(sdkKey, { updateProcessor: td });
+   *
+   *     // flags can be updated at any time:
+   *     td.update(td.flag("flag-key-2")
+   *         .variationForContext("user", "some-user-key", true)
+   *         .fallthroughVariation(false));
+   */
+  export function TestData(): TestData;
+
+  /**
+   * A mechanism for providing dynamically updatable feature flag state in a simplified form to an SDK
+   * client in test scenarios.
+   *
+   * Unlike [[FileData]], this mechanism does not use any external resources. It provides only
+   * the data that the application has put into it using the [[TestData.update]] method.
+   *
+   * @example
+   *     const { TestData } = require('launchdarkly-node-server-sdk/interfaces');
+   * 
+   *     const td = TestData();
+   *     testData.update(td.flag("flag-key-1").booleanFlag().variationForAll(true));
+   *     const client = new LDClient(sdkKey, { updateProcessor: td });
+   *
+   *     // flags can be updated at any time:
+   *     td.update(td.flag("flag-key-2")
+   *         .variationForContext("user", "some-user-key", true)
+   *         .fallthroughVariation(false));
+   *
+   * The above example uses a simple boolean flag, but more complex configurations are possible using
+   * the methods of the [[TestDataFlagBuilder]] that is returned by [[TestData.flag]]. [[TestDataFlagBuilder]]
+   * supports many of the ways a flag can be configured on the LaunchDarkly dashboard, but does not
+   * currently support 1. rule operators other than "in" and "not in", or 2. percentage rollouts.
+   *
+   * If the same `TestData` instance is used to configure multiple `LDClient` instances,
+   * any changes made to the data will propagate to all of the `LDClient`s.
+   *
+   * @see [[FileDataSource]]
+   */
+  export interface TestData {
+    /**
+     * Creates or copies a [[TestDataFlagBuilder]] for building a test flag configuration.
+     *
+     * If the flag key has already been defined in this `TestData` instance,
+     * then the builder starts with the same configuration that was last
+     * provided for this flag.
+     *
+     * Otherwise, it starts with a new default configuration in which the flag
+     * has `true` and `false` variations, is `true` for all users when targeting
+     * is turned on and `false` otherwise, and currently has targeting turned on.
+     * You can change any of those properties and provide more complex behavior
+     * using the `TestDataFlagBuilder` methods.
+     *
+     * Once you have set the desired configuration, pass the builder to
+     * [[TestData.update]].
+     *
+     * @param key the flag key
+     * @returns a flag configuration builder
+     *
+     */
+    flag(key: string): TestDataFlagBuilder;
+
+    /**
+     * Updates the test data with the specified flag configuration.
+     *
+     * This has the same effect as if a flag were added or modified in the
+     * LaunchDarkly dashboard. It immediately propagates the flag changes to
+     * any [[LDClient]] instance(s) that you have already configured to use
+     * this `TestData`. If no `LDClient` has been started yet, it simply adds
+     * this flag to the test data which will be provided to any `LDClient`
+     * that you subsequently configure.
+     *
+     * Any subsequent changes to this `TestDataFlagBuilder` instance do not affect
+     * the test data unless you call `update` again.
+     *
+     * @param flagBuilder a flag configuration builder
+     * @return a promise that will resolve when the feature stores are updated
+     */
+    update(flagBuilder: TestDataFlagBuilder): Promise<any>;
+
+    /**
+     * Copies a full feature flag data model object into the test data.
+     *
+     * It immediately propagates the flag change to any [[LDClient]] instance(s) that you have already
+     * configured to use this `TestData`. If no [[LDClient]] has been started yet, it simply adds
+     * this flag to the test data which will be provided to any LDClient that you subsequently
+     * configure.
+     *
+     * Use this method if you need to use advanced flag configuration properties that are not supported by
+     * the simplified [[TestDataFlagBuilder]] API. Otherwise it is recommended to use the regular
+     * [[flag]]/[[update]] mechanism to avoid dependencies on details of the data model.
+     *
+     * You cannot make incremental changes with [[flag]]/[[update]] to a flag that has been added in this way;
+     * you can only replace it with an entirely new flag configuration.
+     * 
+     * @param flagConfig the flag configuration as a JSON object
+     * @return a promise that will resolve when the feature stores are updated
+     */
+    usePreconfiguredFlag(flagConfig: any): Promise<any>;
+
+    /**
+     * Copies a full segment data model object into the test data.
+     *
+     * It immediately propagates the change to any [[LDClient]] instance(s) that you have already
+     * configured to use this `TestData`. If no [[LDClient]] has been started yet, it simply adds
+     * this segment to the test data which will be provided to any LDClient that you subsequently
+     * configure.
+     *
+     * This method is currently the only way to inject segment data, since there is no builder
+     * API for segments. It is mainly intended for the SDK's own tests of segment functionality,
+     * since application tests that need to produce a desired evaluation state could do so more easily
+     * by just setting flag values.
+     * 
+     * @param segmentConfig the segment configuration as a JSON object
+     * @return a promise that will resolve when the feature stores are updated
+     */
+    usePreconfiguredSegment(segmentConfig: any): Promise<any>;
+  }
+
+  /**
+   * A builder for feature flag configurations to be used with [[TestData]].
+   */
+  export interface TestDataFlagBuilder {
+    /**
+     * A shortcut for setting the flag to use the standard boolean configuration.
+     *
+     * This is the default for all new flags created with [[TestData.flag]]. The
+     * flag will have two variations, `true` and `false` (in that order). It
+     * will return `false` whenever targeting is off and `true` when targeting
+     * is on unless other settings specify otherwise.
+     *
+     * @return the flag builder
+     */
+    booleanFlag(): TestDataFlagBuilder;
+
+    /**
+     * Sets the allowable variation values for the flag.
+     *
+     * The values may be of any JSON-compatible type: boolean, number, string, array,
+     * or object. For instance, a boolean flag normally has `variations(true, false)`;
+     * a string-valued flag might have `variations("red", "green")`; etc.
+     * 
+     * @param values any number of variation values
+     * @return the flag builder
+     */
+    variations(...values: any[]): TestDataFlagBuilder;
+
+    /**
+     * Sets targeting to be on or off for this flag.
+     *
+     * The effect of this depends on the rest of the flag configuration, just
+     * as it does on the real LaunchDarkly dashboard. In the default configuration
+     * that you get from calling [[TestData.flag]] with a new flag key, the flag
+     * will return `false` whenever targeting is off and `true` when targeting
+     * is on.
+     *
+     * @param targetingOn true if targeting should be on
+     * @return the flag builder
+     */
+    on(targetingOn: boolean): TestDataFlagBuilder;
+
+    /**
+     * Specifies the fallthrough variation for a flag. The fallthrough is
+     * the value that is returned if targeting is on and the user was not
+     * matched by a more specific target or rule.
+     *
+     * If a boolean is supplied, and the flag was previously configured with
+     * other variations, this also changes it to a boolean flag.
+     *
+     * @param variation
+     *    either `true` or `false` or the index of the desired fallthrough
+     *    variation: 0 for the first, 1 for the second, etc.
+     * @return the flag builder
+     */
+    fallthroughVariation(variation: boolean | number): TestDataFlagBuilder;
+
+    /**
+     * Specifies the off variation for a flag. This is the variation that is
+     * returned whenever targeting is off.
+     *
+     * If a boolean is supplied, and the flag was previously configured with
+     * other variations, this also changes it to a boolean flag.
+     *
+     * @param variation
+     *    either `true` or `false` or the index of the desired off
+     *    variation: 0 for the first, 1 for the second, etc.
+     * @return the flag builder
+     */
+    offVariation(variation: boolean | number): TestDataFlagBuilder;
+
+    /**
+     * Sets the flag to always return the specified variation for all contexts.
+     *
+     * Targeting is switched on, any existing targets or rules are removed,
+     * and the fallthrough variation is set to the specified value. The off
+     * variation is left unchanged.
+     *
+     * If a boolean is supplied, and the flag was previously configured with
+     * other variations, this also changes it to a boolean flag.
+     *
+     * @param varation
+     *    either `true` or `false` or the index of the desired variation:
+     *    0 for the first, 1 for the second, etc.
+     * @return the flag builder
+     */
+    variationForAll(variation: boolean | number): TestDataFlagBuilder;
+
+    /**
+     * Sets the flag to always return the specified variation value for all contexts.
+     *
+     * The value may be of any valid JSON type. This method changes the flag to have
+     * only a single variation, which is this value, and to return the same variation
+     * regardless of whether targeting is on or off. Any existing targets or rules
+     * are removed.
+     *
+     * @param value The desired value to be returned for all contexts.
+     * @return the flag builder
+     */
+    valueForAll(value: any): TestDataFlagBuilder;
+
+    /**
+     * Sets the flag to return the specified variation for a specific context key
+     * when targeting is on. The context kind for contexts created with this method
+     * will be 'user'.
+     *
+     * This has no effect when targeting is turned off for the flag.
+     *
+     * If the variation is a boolean value and the flag was not already a boolean
+     * flag, this also changes it to be a boolean flag.
+     *
+     * If the variation is an integer, it specifies a variation out of whatever
+     * variation values have already been defined.
+     *
+     * @param contextKey a context key
+     * @param variation
+     *    either `true` or `false` or the index of the desired variation:
+     *    0 for the first, 1 for the second, etc.
+     * @return the flag builder
+     */
+    variationForUser(contextKey: string, variation: boolean | number): TestDataFlagBuilder;
+
+    /**
+     * Sets the flag to return the specified variation for a specific context key
+     * when targeting is on.
+     *
+     * This has no effect when targeting is turned off for the flag.
+     *
+     * If the variation is a boolean value and the flag was not already a boolean
+     * flag, this also changes it to be a boolean flag.
+     *
+     * If the variation is an integer, it specifies a variation out of whatever
+     * variation values have already been defined.
+     *
+     * @param contextKind a context kind
+     * @param contextKey a context key
+     * @param variation
+     *    either `true` or `false` or the index of the desired variation:
+     *    0 for the first, 1 for the second, etc.
+     * @return the flag builder
+     */
+    variationForContext(contextKind: string, contextKey: string, variation: boolean | number): TestDataFlagBuilder;
+
+    /**
+     * Removes any existing rules from the flag. This undoes the effect of methods
+     * like [[ifMatch]].
+     *
+     * @return the same flag builder
+     */
+    clearRules(): TestDataFlagBuilder;
+
+    /**
+     * Removes any existing targets from the flag. This undoes the effect of
+     * methods like [[variationForContext]].
+     *
+     * @return the same flag builder
+     */
+    clearAlltargets(): TestDataFlagBuilder;
+
+    /**
+     * Starts defining a flag rule using the "is one of" operator.
+     *
+     * For example, this creates a rule that returnes `true` if the name is
+     * "Patsy" or "Edina":
+     *
+     *     testData.flag('flag')
+     *             .ifMatch('user', name', 'Patsy', 'Edina')
+     *             .thenReturn(true)
+     *
+     * @param contextKind the kind of the context
+     * @param attribute the context attribute to match against
+     * @param values values to compare to
+     * @return
+     *    a flag rule builder; call `thenReturn` to finish the rule
+     *    or add more tests with another method like `andMatch`
+     */
+    ifMatch(contextKind: string, attribute: string, ...values: any): TestDataRuleBuilder;
+
+    /**
+     * Starts defining a flag rule using the "is not one of" operator.
+     *
+     * For example, this creates a rule that returnes `true` if the name is
+     * neither "Saffron" nor "Bubble":
+     *
+     *     testData.flag('flag')
+     *             .ifNotMatch('user', 'name', 'Saffron', 'Bubble')
+     *             .thenReturn(true)
+     *
+     * @param contextKind the kind of the context
+     * @param attribute the user attribute to match against
+     * @param values values to compare to
+     * @return
+     *    a flag rule builder; call `thenReturn` to finish the rule
+     *    or add more tests with another method like `andNotMatch`
+     */
+    ifNotMatch(contextKind: string, attribute: string, ...values: any): TestDataRuleBuilder;
+  }
+
+  /**
+   * A builder for feature flag rules to be used with [[TestDataFlagBuilder]].
+   *
+   * In the LaunchDarkly model, a flag can have any number of rules, and
+   * a rule can have any number of clauses. A clause is an individual test
+   * such as "name is 'X'". A rule matches a user if all of the rule's
+   * clauses match the user.
+   *
+   * To start defining a rule, use one of the flag builder's matching methods
+   * such as `ifMatch`. This defines the first clause for the rule. Optionally,
+   * you may add more clauses with the rule builder's methods such as `andMatch`.
+   * Finally, call `thenReturn` to finish defining the rule.
+   */
+  export interface TestDataRuleBuilder {
+    /**
+     * Adds another clause using the "is one of" operator.
+     *
+     * For example, this creates a rule that returns `true` if the name is
+     * "Patsy" and the country is "gb":
+     *
+     *     testData.flag('flag')
+     *             .ifMatch('name', 'Patsy')
+     *             .andMatch('country', 'gb')
+     *             .thenReturn(true)
+     *
+     * @param contextKind the kind of the context
+     * @param attribute the user attribute to match against
+     * @param values values to compare to
+     * @return the flag rule builder
+     */
+    andMatch(contextKind: string, attribute: string, ...values: any): TestDataRuleBuilder;
+
+    /**
+     * Adds another clause using the "is not one of" operator.
+     *
+     * For example, this creates a rule that returns `true` if the name is
+     * "Patsy" and the country is not "gb":
+     *
+     *     testData.flag('flag')
+     *             .ifMatch('name', 'Patsy')
+     *             .andNotMatch('country', 'gb')
+     *             .thenReturn(true)
+     *
+     * @param contextKind the kind of the context
+     * @param attribute the user attribute to match against
+     * @param values values to compare to
+     * @return the flag rule builder
+     */
+    andNotMatch(contextKind: string, attribute: string, ...values: any): TestDataRuleBuilder;
+
+    /**
+     * Finishes defining the rule, specifying the result value as either a boolean or an index
+     *
+     * If the variation is a boolean value and the flag was not already a boolean
+     * flag, this also changes it to be a boolean flag.
+     *
+     * If the variation is an integer, it specifies a variation out of whatever
+     * variation values have already been defined.
+
+     * @param variation
+     *    either `true` or `false` or the index of the desired variation:
+     *    0 for the first, 1 for the second, etc.
+     * @return the flag rule builder
+     */
+    thenReturn(variation: boolean | number): TestDataFlagBuilder;
+  }
+}
+
+/**
+ * This module contains types that allow customization of LaunchDarkly components, and
+ * interfaces to other advanced SDK features.
+ *
+ * Most applications will not need to refer to these types. You will use them if you are creating a
+ * plug-in component, such as a database integration, or if you use advanced SDK features.
+ *
+ * Currently this module contains no implementation code, but only TypeScript interfaces.
+ */
+declare module 'launchdarkly-node-server-sdk/interfaces' {
+  import { EventEmitter } from 'events';
+
+  /**
+   * A read-only data store that allows querying of user membership in Big Segments.
+   *
+   * Big Segments are a specific type of user segments. For more information, read the LaunchDarkly
+   * documentation: https://docs.launchdarkly.com/home/users/big-segments
+   */
+  export interface BigSegmentStore {
+    /**
+     * Queries information about the overall state of the store.
+     *
+     * The resolved value of the Promise should always be a [[BigSegmentStoreMetadata]] object. If
+     * the store is accessible but contains no metadata, the object's `lastUpToDate` property can be
+     * undefined. If the store is not accessible due to a database error, the method can throw an
+     * exception/reject the promise.
+     *
+     * This method will be called only when the SDK needs the latest state, so it should not be cached.
+     *
+     * @returns a Promise for the result of the query
+     */
+    getMetadata(): Promise<BigSegmentStoreMetadata>;
+
+    /**
+     * Queries the store for a snapshot of the current segment state for a specific user.
+     *
+     * The userHash is a base64-encoded string produced by hashing the user key as defined by
+     * the Big Segments specification; the store implementation does not need to know the details
+     * of how this is done, because it deals only with already-hashed keys, but the string can be
+     * assumed to only contain characters that are valid in base64.
+     *
+     * The resolved value of the Promise should be either a [[BigSegmentStoreMembership]], or
+     * undefined if the user is not referenced in any Big Segments (this is equivalent to a
+     * [[BigSegmentStoreMembership]] that has no properties).
+     *
+     * @param userHash identifies the user
+     * @returns a Promise for the result of the query.
+     */
+    getUserMembership(userHash: string): Promise<BigSegmentStoreMembership | undefined>;
+
+    /**
+     * Releases any resources being used by the store.
+     */
+    close(): void;
+  }
+
+  /**
+   * Values returned by BigSegmentStore.getMetadata().
+   */
+  export interface BigSegmentStoreMetadata {
+    /**
+     * The Unix epoch millisecond timestamp of the last update to the BigSegmentStore. It is
+     * undefined if the store has never been updated.
+     */
+    lastUpToDate?: number
+  }
+
+  /**
+   * The return type of [[BigSegmentStore.getUserMembership]], describing which Big Segments a
+   * specific user is included in or excluded from.
+   *
+   * This object may be cached by the SDK, so it should not be modified after it is created. It
+   * is a snapshot of the segment membership state at one point in time.
+   */
+  export interface BigSegmentStoreMembership {
+    /**
+     * Each property key in this object is a "segment reference", which is how segments are
+     * identified in Big Segment data. This string is not identical to the segment key-- the SDK
+     * will add other information. The store implementation should not be concerned with the
+     * format of the string.
+     *
+     * A true value means that the user is explicitly included in the segment. A false value
+     * means that the user is explicitly excluded from the segment-- and is not also explicitly
+     * included (that is, if both an include and an exclude existed in the data, the include would
+     * take precedence). If the user's status in a particular segment is undefined, there should
+     * be no key or value for that segment.
+     */
+    [segmentRef: string]: boolean;
+  }
+
+  /**
+   * An interface for querying the status of a Big Segment store.
+   *
+   * The Big Segment store is the component that receives information about Big Segments, normally
+   * from a database populated by the LaunchDarkly Relay Proxy. Big Segments are a specific type
+   * of user segments. For more information, read the LaunchDarkly documentation:
+   * https://docs.launchdarkly.com/home/users/big-segments
+   *
+   * An implementation of this interface is returned by {@link LDClient.bigSegmentStoreStatusProvider}.
+   * Application code never needs to implement this interface.
+   *
+   * Note that this type inherits from `EventEmitter`, so you can use the standard `on()`, `once()`,
+   * and `off()` methods to receive status change events. The standard `EventEmitter` methods are
+   * not documented here; see the {@link https://nodejs.org/api/events.html#events_class_eventemitter|Node API documentation}.
+   * The type of the status change event is `"change"`, and its value is the same value that would
+   * be returned by {@link getStatus}.
+   */
+  export interface BigSegmentStoreStatusProvider extends EventEmitter {
+    /**
+     * Gets the current status of the store, if known.
+     *
+     * @returns a {@link BigSegmentStoreStatus}, or `undefined` if the SDK has not yet queried the
+     *   Big Segment store status
+     */
+    getStatus(): BigSegmentStoreStatus | undefined;
+
+    /**
+     * Gets the current status of the store, querying it if the status has not already been queried.
+     *
+     * @returns a Promise for the status of the store
+     */
+    requireStatus(): Promise<BigSegmentStoreStatus>;
+  }
+
+  /**
+   * Information about the status of a Big Segment store, provided by {@link BigSegmentStoreStatusProvider}.
+   *
+   * Big Segments are a specific type of user segments. For more information, read the LaunchDarkly
+   * documentation: https://docs.launchdarkly.com/home/users/big-segments
+   */
+  export interface BigSegmentStoreStatus {
+    /**
+     * True if the Big Segment store is able to respond to queries, so that the SDK can
+     * evaluate whether a user is in a segment or not.
+     *
+     * If this property is false, the store is not able to make queries (for instance, it may not have
+     * a valid database connection). In this case, the SDK will treat any reference to a Big Segment
+     * as if no users are included in that segment. Also, the {@link LDEvaluationReason} associated
+     * with any flag evaluation that references a Big Segment when the store is not available will
+     * have a `bigSegmentsStatus` of `"STORE_ERROR"`.
+     */
+    available: boolean;
+
+    /**
+     * True if the Big Segment store is available, but has not been updated within the amount of time
+     * specified by {@link LDBigSegmentsOptions.staleAfter}.
+     *
+     * This may indicate that the LaunchDarkly Relay Proxy, which populates the store, has stopped
+     * running or has become unable to receive fresh data from LaunchDarkly. Any feature flag
+     * evaluations that reference a Big Segment will be using the last known data, which may be out
+     * of date.
+     */
+    stale: boolean;
+  }
+
+  /**
+   * Used internally to describe the type of data being queried or updated, such as feature flags or
+   * user segments.
+   *
+   * This is the actual type of the `kind` parameter in `LDFeatureStore` methods. Those methods are
+   * still declared as taking `any` for backward compatibility, but in the future they will reference
+   * this type.
+   */
+  export interface DataKind {
+    /**
+     * A string such as `"features"` or `"segments"` which can be used in keys to distinguish this
+     * kind of data from other kinds.
+     */
+    namespace: string;
+  }
+
+  /**
+   * Used internally to describe the basic properties of stored data such as feature flags or user
+   * segments.
+   *
+   * This is the actual type of parameters and return values in `LDFeatureStore` methods that refer
+   * to a flag or segment item. Those methods still use the `object` type for backward compatibility.
+   */
+  export interface VersionedData {
+    /**
+     * The item's unique key, such as a feature flag key.
+     */
+    key: string;
+
+    /**
+     * A version number that LaunchDarkly will increment each time this item is changed.
+     */
+    version: number;
+
+    /**
+     * True if this is a deleted item placeholder (tombstone).
+     */
+    deleted?: boolean;
+  }
+
+  /**
+   * Used internally to describe a set of stored data items of the same kind, such as feature flags
+   * or user segments. The string key for each item is the same as the item's `key` property.
+   */
+  export type KeyedItems<T> = Record<string, T>;
+
+  /**
+   * Used internally for data store implementations that require items in an ordered list rather
+   * than as object properties.
+   */
+  export interface DataCollection<T> {
+    /**
+     * Describes the kind of items, such as feature flags or user segments.
+     */
+    kind: DataKind;
+
+    /**
+     * An ordered list of items of this kind.
+     */
+    items: Array<T>;
+  }
+
+  /**
+   * Used internally to describe a full set of environment data, which can include both feature
+   * flags and user segments. The string key for each item is the `namespace` property of a
+   * [[DataKind]].
+   */
+  export type FullDataSet<T> = Record<string, KeyedItems<T>>;
+
+  /**
+   * Base interface for a simplified subset of the functionality of `LDFeatureStore`, to be used in
+   * conjunction with `CachingStoreWrapper`.
+   *
+   * @see [[PersistentDataStore]]
+   * @see [[PersistentDataStoreNonAtomic]]
+   */
+  export interface PersistentDataStoreBase {
+    /**
+     * Get an entity from the store.
+     *
+     * @param kind
+     *   The type of data to be accessed. The store should not make any assumptions about the format
+     *   of the data, but just return a JSON object.
+     *
+     * @param key
+     *   The unique key of the entity within the specified collection.
+     *
+     * @param callback
+     *   Will be called with the retrieved entity, or null if not found.
+     */
+    getInternal(kind: DataKind, key: string, callback: (res: VersionedData) => void): void;
+
+    /**
+     * Get all entities from a collection.
+     *
+     * The store should filter out any entities with the property `deleted: true`.
+     *
+     * @param kind
+     *   The type of data to be accessed. The store should not make any assumptions about the format
+     *   of the data, but just return an object in which each key is the `key` property of an entity
+     *   and the value is the entity. The actual type of this parameter is [[interfaces.DataKind]].
+     *
+     * @param callback
+     *   Will be called with the resulting map.
+     */
+    getAllInternal(kind: DataKind, callback: (res: KeyedItems<VersionedData>) => void): void;
+
+    /**
+     * Add an entity or update an existing entity.
+     *
+     * @param kind
+     *   The type of data to be accessed.
+     *
+     * @param item
+     *   The contents of the entity, as an object that can be converted to JSON. The store
+     *   should check the `version` property of this object, and should *not* overwrite any
+     *   existing data if the existing `version` is greater than or equal to that value.
+     *
+     * @param callback
+     *   Will be called after the upsert operation is complete.
+     */
+    upsertInternal(kind: DataKind, item: VersionedData, callback: (err: Error, finalItem: VersionedData) => void): void;
+
+    /**
+     * Tests whether the store is initialized.
+     *
+     * "Initialized" means that the store has been populated with data, either by the client
+     * having called `init()` within this process, or by another process (if this is a shared
+     * database).
+     *
+     * @param callback
+     *   Will be called back with the boolean result.
+     */
+    initializedInternal(callback: (isInitialized: boolean) => void): void;
+
+    /**
+     * Releases any resources being used by the feature store.
+     */
+    close(): void;
+  }
+
+  /**
+   * Interface for a simplified subset of the functionality of `LDFeatureStore`, to be used in
+   * conjunction with `CachingStoreWrapper`.
+   *
+   * @see [[PersistentDataStoreNonAtomic]]
+   */
+  export interface PersistentDataStore extends PersistentDataStoreBase {
+    /**
+     * Initialize the store, overwriting any existing data.
+     *
+     * @param allData
+     *   An object in which each key is the "namespace" of a collection (e.g. `"features"`) and
+     *   the value is an object that maps keys to entities.
+     *
+     * @param callback
+     *   Will be called when the store has been initialized.
+     */
+    initInternal(allData: FullDataSet<VersionedData>, callback: () => void): void;
+  }
+
+  /**
+   * Interface for a simplified subset of the functionality of `LDFeatureStore`, to be used in
+   * conjunction with `CachingStoreWrapper`.
+   *
+   * This is a variant of [[PersistentDataStore]] for databases that require somewhat different
+   * initialization semantics, where we must specify a consistent ordering of writes.
+   *
+   * @see [[PersistentDataStore]]
+   */
+  export interface PersistentDataStoreNonAtomic {
+    /**
+     * Initialize the store, overwriting any existing data.
+     *
+     * @param allData
+     *   A list of data item collections in the order they should be written.
+     *
+     * @param callback
+     *   Will be called when the store has been initialized.
+     */
+    initOrderedInternal(allData: Array<DataCollection<VersionedData>>, callback: () => void): void;
+  }
+}
+
+/**
+ * @ignore
+ */
+declare module 'launchdarkly-node-server-sdk/streaming' {
+  import {
+    LDOptions,
+    LDFeatureRequestor,
+    LDStreamProcessor
+  } from 'launchdarkly-node-server-sdk';
+
+  function StreamProcessor(
+    sdkKey: string,
+    options: LDOptions,
+    requestor: LDFeatureRequestor
+  ): LDStreamProcessor;
+  export = StreamProcessor;
+}
+
+/**
+ * @ignore
+ */
+declare module 'launchdarkly-node-server-sdk/requestor' {
+  import { LDOptions, LDFeatureRequestor } from 'launchdarkly-node-server-sdk';
+
+  function Requestor(sdkKey: string, options: LDOptions): LDFeatureRequestor;
+  export = Requestor;
+}
+
+/**
+ * @ignore
+ */
+declare module 'launchdarkly-node-server-sdk/feature_store' {
+  import { LDFeatureStore } from 'launchdarkly-node-server-sdk';
+
+  function InMemoryFeatureStore(): LDFeatureStore;
+  export = InMemoryFeatureStore;
+}
+
+/**
+ * @ignore
+ */
+declare module 'launchdarkly-node-server-sdk/caching_store_wrapper' {
+  import { LDFeatureStore } from 'launchdarkly-node-server-sdk';
+  import { PersistentDataStore, PersistentDataStoreNonAtomic } from 'launchdarkly-node-server-sdk/interfaces';
+
+  /**
+   * A base feature store implementation used by database integrations.
+   */
+  class CachingStoreWrapper implements LDFeatureStore {
+    /**
+     * Creates a feature store implementation with standard caching behavior for a persistent store.
+     *
+     * @param storeImplementation internal implementation object for a specific database type
+     * @param ttl cache TTL in seconds, or 0 for no caching
+     * @param description name of the database
+     */
+    public constructor(
+      storeImplementation: PersistentDataStore | PersistentDataStoreNonAtomic,
+      ttl: number,
+      description: string
+    );
+
+    public get(kind: object, key: string, callback: (res: object) => void): void;
+
+    public all(kind: object, callback: (res: object) => void): void;
+
+    public init(allData: object, callback: () => void): void;
+
+    public delete(kind: object, key: string, version: string, callback: () => void): void;
+
+    public upsert(kind: object, data: object, callback: () => void): void;
+
+    public initialized(callback: (isInitialized: boolean) => void): void;
+
+    public close(): void;
+  }
+  export = CachingStoreWrapper;
+}
+
+/**
+ * @ignore
+ */
+declare module 'launchdarkly-node-server-sdk/sharedtest/store_tests' {
+  import * as ld from 'launchdarkly-node-server-sdk';
+  import * as interfaces from 'launchdarkly-node-server-sdk/interfaces';
+
+  /**
+   * A standard test suite that should be run on every persistent feature store implementation.
+   *
+   * This test suite uses `jest` and should be run inside a `describe` block.
+   *
+   * Store implementations must meet the following requirements to be testable with this suite:
+   *
+   * - They must support setting a key prefix. The tests will always pass a non-empty prefix.
+   *
+   * - They must support caching with a positive cache TTL in seconds, or a zero cache TTL to
+   * disable caching.
+   *
+   * - All instances created during the tests must share the same database, so that the tests
+   * can verify that they can read pre-existing data and will not interfere with any keys
+   * that use a different prefix.
+   *
+   * Do not call `runPersistentFeatureStoreTests` and `runBigSegmentStoreTests` from tests
+   * in separate files, if `jest` parallelization is enabled; they can interfere with each
+   * other's database state if they are interleaved.
+   *
+   * @param createStore A function that creates a feature store instance with the specified
+   *   key prefix and cache TTL.
+   * @param clearExistingData An asynchronous function that removes any existing data from
+   *   the database for the specified key prefix only.
+   * @param setConcurrentModificationHook If provided, this enables additional tests in which
+   *   another store instance is used to make a competing update to the same data while an
+   *   update is already in progress. The function should create a store instance which,
+   *   during any upsert operation, will call "hook" and await the result at a point when a
+   *   race condition is possible (for instance, after reading the old version of an item but
+   *   before writing the new version, if those are not atomic). Caching should be disabled.
+   */
+  export function runPersistentFeatureStoreTests(
+    createStore: (prefix: string, cacheTTL: number, logger: ld.LDLogger) => ld.LDFeatureStore,
+    clearExistingData: (prefix: string) => Promise<void>,
+    createStoreWithConcurrentUpdateHook?: (prefix: string, logger: ld.LDLogger, hook: () => Promise<void>) => void,
+  ): void;
+
+  /**
+   * A standard test suite that should be run on every Big Segment store implementation.
+   *
+   * This test suite uses `jest` and should be run inside a `describe` block.
+   *
+   * Store implementations must meet the following requirements to be testable with this suite:
+   *
+   * - They must support setting a key prefix. The tests will always pass a non-empty prefix.
+   *
+   * - All instances created during the tests must share the same database, so that the tests
+   * can verify that they can read pre-existing data and will not interfere with any keys
+   * that use a different prefix.
+   *
+   * Do not call `runPersistentFeatureStoreTests` and `runBigSegmentStoreTests` from tests
+   * in separate files, if `jest` parallelization is enabled; they can interfere with each
+   * other's database state if they are interleaved.
+   *
+   * @param createStore A function that creates a Big Segment store instance with the
+   *   specified key prefix.
+   * @param clearExistingData An asynchronous function that removes any existing data from
+   *   the database for the specified key prefix only.
+   * @param setMetadata An asynchronous function that updates the store metadata.
+   * @param setSegments An asynchronous function that sets a user's Big Segment state.
+   */
+  export function runBigSegmentStoreTests(
+    createStore: (prefix: string, logger: ld.LDLogger) => interfaces.BigSegmentStore,
+    clearExistingData: (prefix: string) => Promise<void>,
+    setMetadata: (prefix: string, metadata: interfaces.BigSegmentStoreMetadata) => Promise<void>,
+    setSegments: (prefix: string, userHashKey: string, included: string[], excluded: string[]) => Promise<void>
+  ): void;
+}