pi-cursor-sdk 0.1.1 → 0.1.3

package/node_modules/@statsig/js-client/src/EvaluationStore.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_core_1 = require("@statsig/client-core");
+const V1InitializeContainer_1 = require("./V1InitializeContainer");
+const V2InitializeContainer_1 = require("./V2InitializeContainer");
+class EvaluationStore {
+    constructor(_sdkKey) {
+        this._sdkKey = _sdkKey;
+        this._valuesForExternalUse = null;
+        this._values = null;
+        this._source = 'Uninitialized';
+        this._lcut = 0;
+        this._receivedAt = 0;
+        this._bootstrapMetadata = null;
+        this._warnings = new Set();
+    }
+    reset() {
+        this._values = null;
+        this._valuesForExternalUse = null;
+        this._source = 'Loading';
+        this._lcut = 0;
+        this._receivedAt = 0;
+        this._bootstrapMetadata = null;
+        this._warnings.clear();
+    }
+    finalize() {
+        if (this._values) {
+            return;
+        }
+        this._source = 'NoValues';
+    }
+    getValues() {
+        // we do not give out the actual _values object to avoid mutating it
+        return this._valuesForExternalUse;
+    }
+    setValues(result, user) {
+        var _a, _b;
+        if (!result) {
+            return false;
+        }
+        const values = (0, client_core_1._typedJsonParse)(result.data, 'has_updates', 'EvaluationResponse');
+        if (values == null) {
+            return false;
+        }
+        this._source = result.source;
+        if ((values === null || values === void 0 ? void 0 : values.has_updates) !== true) {
+            return true;
+        }
+        const updatedLcut = (_a = values.time) !== null && _a !== void 0 ? _a : 0;
+        if (updatedLcut < this._lcut) {
+            return true;
+        }
+        this._valuesForExternalUse = (0, client_core_1._typedJsonParse)(result.data, 'has_updates', 'EvaluationResponse');
+        this._lcut = values.time;
+        this._receivedAt = result.receivedAt;
+        if (values.response_format === 'init-v2') {
+            this._values = new V2InitializeContainer_1.V2InitializeContainer(values);
+        }
+        else {
+            this._values = new V1InitializeContainer_1.V1InitializeContainer(values);
+        }
+        this._bootstrapMetadata = this._extractBootstrapMetadata(result.source, values);
+        if (result.source && values.user) {
+            this._setWarningState(user, values);
+        }
+        client_core_1.SDKFlags.setFlags(this._sdkKey, (_b = values.sdk_flags) !== null && _b !== void 0 ? _b : {});
+        return true;
+    }
+    getWarnings() {
+        if (this._warnings.size === 0) {
+            return undefined;
+        }
+        return Array.from(this._warnings);
+    }
+    getGate(name) {
+        const res = this._values ? this._values.getGate(name) : null;
+        return this._getDetailedStoreResult(res);
+    }
+    getConfig(name) {
+        const res = this._values ? this._values.getConfig(name) : null;
+        return this._getDetailedStoreResult(res);
+    }
+    getConfigList() {
+        if (!this._values) {
+            return [];
+        }
+        return this._values.getConfigList();
+    }
+    getLayer(name) {
+        const res = this._values ? this._values.getLayer(name) : null;
+        return this._getDetailedStoreResult(res);
+    }
+    getParamStore(name) {
+        const res = this._values ? this._values.getParamStore(name) : null;
+        return this._getDetailedStoreResult(res);
+    }
+    getSource() {
+        return this._source;
+    }
+    getExposureMapping() {
+        var _a;
+        return (_a = this._values) === null || _a === void 0 ? void 0 : _a.getExposureMapping();
+    }
+    _extractBootstrapMetadata(source, values) {
+        if (source !== 'Bootstrap') {
+            return null;
+        }
+        const bootstrapMetadata = {};
+        if (values.user) {
+            bootstrapMetadata.user = values.user;
+        }
+        if (values.sdkInfo) {
+            bootstrapMetadata.generatorSDKInfo = values.sdkInfo;
+        }
+        bootstrapMetadata.lcut = values.time;
+        return bootstrapMetadata;
+    }
+    _getDetailedStoreResult(result) {
+        return {
+            result,
+            details: this._getDetails(result == null),
+        };
+    }
+    _setWarningState(user, values) {
+        var _a, _b;
+        const stableID = client_core_1.StableID.get(this._sdkKey);
+        if (((_a = user.customIDs) === null || _a === void 0 ? void 0 : _a.stableID) !== stableID && // don't throw if they're both undefined
+            (((_b = user.customIDs) === null || _b === void 0 ? void 0 : _b.stableID) || stableID)) {
+            this._warnings.add('StableIDMismatch');
+            return;
+        }
+        if ('user' in values) {
+            const bootstrapUser = values['user'];
+            const userForComparison = Object.assign(Object.assign({}, user), { analyticsOnlyMetadata: undefined, privateAttributes: undefined });
+            if ((0, client_core_1._getFullUserHash)(userForComparison) !== (0, client_core_1._getFullUserHash)(bootstrapUser)) {
+                this._warnings.add('PartialUserMatch');
+            }
+        }
+    }
+    getCurrentSourceDetails() {
+        if (this._source === 'Uninitialized' || this._source === 'NoValues') {
+            return { reason: this._source };
+        }
+        const sourceDetails = {
+            reason: this._source,
+            lcut: this._lcut,
+            receivedAt: this._receivedAt,
+        };
+        if (this._warnings.size > 0) {
+            sourceDetails.warnings = Array.from(this._warnings);
+        }
+        return sourceDetails;
+    }
+    _getDetails(isUnrecognized) {
+        var _a, _b;
+        const sourceDetails = this.getCurrentSourceDetails();
+        let reason = sourceDetails.reason;
+        const warnings = (_a = sourceDetails.warnings) !== null && _a !== void 0 ? _a : [];
+        if (this._source === 'Bootstrap' && warnings.length > 0) {
+            reason = reason + warnings[0];
+        }
+        if (reason !== 'Uninitialized' && reason !== 'NoValues') {
+            const subreason = isUnrecognized ? 'Unrecognized' : 'Recognized';
+            reason = `${reason}:${subreason}`;
+        }
+        const bootstrapMetadata = this._source === 'Bootstrap'
+            ? (_b = this._bootstrapMetadata) !== null && _b !== void 0 ? _b : undefined
+            : undefined;
+        if (bootstrapMetadata) {
+            sourceDetails.bootstrapMetadata = bootstrapMetadata;
+        }
+        return Object.assign(Object.assign({}, sourceDetails), { reason });
+    }
+}
+exports.default = EvaluationStore;

package/node_modules/@statsig/js-client/src/InitializeContainer.d.ts

@@ -0,0 +1,9 @@
+import { DynamicConfigEvaluation, GateEvaluation, LayerEvaluation, ParamStoreConfig, SecondaryExposure } from '@statsig/client-core';
+export interface InitializeContainer {
+    getGate(name: string): GateEvaluation | null;
+    getConfig(name: string): DynamicConfigEvaluation | null;
+    getLayer(name: string): LayerEvaluation | null;
+    getParamStore(name: string): ParamStoreConfig | null;
+    getConfigList(): string[];
+    getExposureMapping(): Record<string, SecondaryExposure> | undefined;
+}

package/node_modules/@statsig/js-client/src/InitializeContainer.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/node_modules/@statsig/js-client/src/Network.d.ts

@@ -0,0 +1,9 @@
+import { NetworkCore, NetworkPriority, StatsigClientEmitEventFunc, StatsigUser } from '@statsig/client-core';
+import { StatsigOptions } from './StatsigOptions';
+export default class StatsigNetwork extends NetworkCore {
+    private _initializeUrlConfig;
+    private _option;
+    constructor(options: StatsigOptions | null, emitter?: StatsigClientEmitEventFunc);
+    fetchEvaluations(sdkKey: string, current: string | null, priority?: NetworkPriority, user?: StatsigUser, isCacheValidFor204?: boolean): Promise<string | null>;
+    private _fetchEvaluations;
+}

package/node_modules/@statsig/js-client/src/Network.js

@@ -0,0 +1,74 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_core_1 = require("@statsig/client-core");
+const EvaluationResponseDeltas_1 = require("./EvaluationResponseDeltas");
+class StatsigNetwork extends client_core_1.NetworkCore {
+    constructor(options, emitter) {
+        super(options, emitter);
+        const config = options === null || options === void 0 ? void 0 : options.networkConfig;
+        this._option = options;
+        this._initializeUrlConfig = new client_core_1.UrlConfiguration(client_core_1.Endpoint._initialize, config === null || config === void 0 ? void 0 : config.initializeUrl, config === null || config === void 0 ? void 0 : config.api, config === null || config === void 0 ? void 0 : config.initializeFallbackUrls);
+    }
+    fetchEvaluations(sdkKey, current, priority, user, isCacheValidFor204) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f;
+            const cache = current
+                ? (0, client_core_1._typedJsonParse)(current, 'has_updates', 'InitializeResponse')
+                : null;
+            let data = {
+                user,
+                hash: (_c = (_b = (_a = this._option) === null || _a === void 0 ? void 0 : _a.networkConfig) === null || _b === void 0 ? void 0 : _b.initializeHashAlgorithm) !== null && _c !== void 0 ? _c : 'djb2',
+                deltasResponseRequested: false,
+                full_checksum: null,
+            };
+            if (cache === null || cache === void 0 ? void 0 : cache.has_updates) {
+                const hasHashChanged = (cache === null || cache === void 0 ? void 0 : cache.hash_used) !==
+                    ((_f = (_e = (_d = this._option) === null || _d === void 0 ? void 0 : _d.networkConfig) === null || _e === void 0 ? void 0 : _e.initializeHashAlgorithm) !== null && _f !== void 0 ? _f : 'djb2');
+                data = Object.assign(Object.assign({}, data), { sinceTime: isCacheValidFor204 && !hasHashChanged ? cache.time : 0, previousDerivedFields: 'derived_fields' in cache && isCacheValidFor204
+                        ? cache.derived_fields
+                        : {}, deltasResponseRequested: true, full_checksum: cache.full_checksum, partialUserMatchSinceTime: !hasHashChanged ? cache.time : 0 });
+            }
+            return this._fetchEvaluations(sdkKey, cache, data, priority);
+        });
+    }
+    _fetchEvaluations(sdkKey, cache, data, priority) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const response = yield this.post({
+                sdkKey,
+                urlConfig: this._initializeUrlConfig,
+                data,
+                retries: 2,
+                isStatsigEncodable: true,
+                priority,
+            });
+            if ((response === null || response === void 0 ? void 0 : response.code) === 204) {
+                return '{"has_updates": false}';
+            }
+            if ((response === null || response === void 0 ? void 0 : response.code) !== 200) {
+                return (_a = response === null || response === void 0 ? void 0 : response.body) !== null && _a !== void 0 ? _a : null;
+            }
+            if ((cache === null || cache === void 0 ? void 0 : cache.has_updates) !== true ||
+                ((_b = response.body) === null || _b === void 0 ? void 0 : _b.includes('"is_delta":true')) !== true ||
+                data.deltasResponseRequested !== true) {
+                return response.body;
+            }
+            const result = (0, EvaluationResponseDeltas_1._resolveDeltasResponse)(cache, response.body);
+            if (typeof result === 'string') {
+                return result;
+            }
+            // retry without deltas
+            return this._fetchEvaluations(sdkKey, cache, Object.assign(Object.assign(Object.assign({}, data), result), { deltasResponseRequested: false }), priority);
+        });
+    }
+}
+exports.default = StatsigNetwork;

package/node_modules/@statsig/js-client/src/ParamStoreGetterFactory.d.ts

@@ -0,0 +1,3 @@
+import { ParamStoreConfig, ParameterStoreEvaluationOptions, TypedGet } from '@statsig/client-core';
+import StatsigClient from './StatsigClient';
+export declare function _makeParamStoreGetter(client: StatsigClient, config: ParamStoreConfig | null, options: ParameterStoreEvaluationOptions | undefined): TypedGet;

package/node_modules/@statsig/js-client/src/ParamStoreGetterFactory.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._makeParamStoreGetter = void 0;
+const client_core_1 = require("@statsig/client-core");
+const NO_EXPOSURE_OPT = {
+    disableExposureLog: true,
+};
+function _shouldLogExposure(options) {
+    return options == null || options.disableExposureLog === false;
+}
+function _shouldReturnFallback(value, fallback) {
+    return fallback != null && !(0, client_core_1._isTypeMatch)(value, fallback);
+}
+function _getMappedStaticValue(param, _options) {
+    return param.value;
+}
+function _getMappedGateValue(client, param, options) {
+    const gate = client.getFeatureGate(param.gate_name, _shouldLogExposure(options) ? undefined : NO_EXPOSURE_OPT);
+    if (gate.value) {
+        return param.pass_value;
+    }
+    return param.fail_value;
+}
+function _getMappedDynamicConfigValue(client, param, fallback, options) {
+    const config = client.getDynamicConfig(param.config_name, _shouldLogExposure(options) ? undefined : NO_EXPOSURE_OPT);
+    const value = config.get(param.param_name);
+    if (_shouldReturnFallback(value, fallback)) {
+        return fallback;
+    }
+    return value;
+}
+function _getMappedExperimentValue(client, param, fallback, options) {
+    const experiment = client.getExperiment(param.experiment_name, _shouldLogExposure(options) ? undefined : NO_EXPOSURE_OPT);
+    const value = experiment.get(param.param_name);
+    if (_shouldReturnFallback(value, fallback)) {
+        return fallback;
+    }
+    return value;
+}
+function _getMappedLayerValue(client, param, fallback, options) {
+    const layer = client.getLayer(param.layer_name, _shouldLogExposure(options) ? undefined : NO_EXPOSURE_OPT);
+    const value = layer.get(param.param_name);
+    if (_shouldReturnFallback(value, fallback)) {
+        return fallback;
+    }
+    return value;
+}
+function _makeParamStoreGetter(client, config, options) {
+    return (paramName, fallback) => {
+        if (config == null) {
+            return fallback;
+        }
+        const param = config[paramName];
+        if (param == null ||
+            (fallback != null && (0, client_core_1._typeOf)(fallback) !== param.param_type)) {
+            return fallback;
+        }
+        switch (param.ref_type) {
+            case 'static':
+                return _getMappedStaticValue(param, options);
+            case 'gate':
+                return _getMappedGateValue(client, param, options);
+            case 'dynamic_config':
+                return _getMappedDynamicConfigValue(client, param, fallback, options);
+            case 'experiment':
+                return _getMappedExperimentValue(client, param, fallback, options);
+            case 'layer':
+                return _getMappedLayerValue(client, param, fallback, options);
+            default:
+                return fallback;
+        }
+    };
+}
+exports._makeParamStoreGetter = _makeParamStoreGetter;

package/node_modules/@statsig/js-client/src/StatsigClient.d.ts

@@ -0,0 +1,244 @@
+import { DataAdapterAsyncOptions, DataAdapterSyncOptions, EvaluationsDataAdapter, ExperimentEvaluationOptions, FeatureGateEvaluationOptions, LayerEvaluationOptions, PrecomputedEvaluationsContext, PrecomputedEvaluationsInterface, StatsigClientBase, StatsigEvent, StatsigUpdateDetails, StatsigUser } from '@statsig/client-core';
+import type { StatsigOptions } from './StatsigOptions';
+type AsyncUpdateOptions = DataAdapterAsyncOptions;
+type SyncUpdateOptions = DataAdapterSyncOptions;
+export default class StatsigClient extends StatsigClientBase<EvaluationsDataAdapter> implements PrecomputedEvaluationsInterface {
+    private _store;
+    private _user;
+    private _network;
+    private _possibleFirstTouchMetadata;
+    private _sdkInstanceID;
+    /**
+     * Retrieves an instance of the StatsigClient based on the provided SDK key.
+     *  If no SDK key is provided, the method returns the most recently created instance of the StatsigClient.
+     *  The method ensures that each unique SDK key corresponds to a single instance of StatsigClient, effectively implementing a singleton pattern for each key.
+     *  If no instance exists for the given SDK key, a new StatsigClient instance will be created and returned.
+     *
+     * @param {string} [sdkKey] - Optional. The SDK key used to identify a specific instance of the StatsigClient. If omitted, the method returns the last created instance.
+     * @returns {StatsigClient} Returns the StatsigClient instance associated with the given SDK key, creating a new one if needed.
+     */
+    static instance(sdkKey?: string): StatsigClient;
+    /**
+     * StatsigClient constructor
+     *
+     * @param {string} sdkKey A Statsig client SDK key. eg "client-xyz123..."
+     * @param {StatsigUser} user StatsigUser object containing various attributes related to a user.
+     * @param {StatsigOptions | null} options StatsigOptions, used to customize the behavior of the SDK.
+     */
+    constructor(sdkKey: string, user: StatsigUser, options?: StatsigOptions | null);
+    /**
+     * Initializes the StatsigClient using cached values. This method sets up the client synchronously by utilizing previously cached values.
+     * After initialization, cache values are updated in the background for future use, either in subsequent sessions or when `updateUser` is called.
+     * This is useful for quickly starting with the last-known-good configurations while refreshing data to keep settings up-to-date.
+     *
+     * @see {@link initializeAsync} for the asynchronous version of this method.
+     */
+    initializeSync(options?: SyncUpdateOptions): StatsigUpdateDetails;
+    /**
+     * Initializes the StatsigClient asynchronously by first using cached values and then updating to the latest values from the network.
+     * Once the network values are fetched, they replace the existing cached values. If this method's promise is not awaited,
+     * there might be a transition from cached to network values during the session, which can affect consistency.
+     * This method is useful when it's acceptable to begin with potentially stale data and switch to the latest configuration as it becomes available.
+     *
+     * @param {AsyncUpdateOptions} [options] - Optional. Additional options to customize the method call.
+     * @returns {Promise<void>} A promise that resolves once the client is fully initialized with the latest values from the network or a timeout (if set) is hit.
+     * @see {@link initializeSync} for the synchronous version of this method.
+     */
+    initializeAsync(options?: AsyncUpdateOptions): Promise<StatsigUpdateDetails>;
+    /**
+     * Synchronously updates the user in the Statsig client and switches the internal state to use cached values for the newly specified user.
+     * After the initial switch to cached values, this method updates these values in the background, preparing them for future sessions or subsequent calls to updateUser.
+     * This method ensures the client is quickly ready with available data.
+     *
+     * @param {StatsigUser} user - The new StatsigUser for which the client should update its internal state.
+     * @see {@link updateUserAsync} for the asynchronous version of this method.
+     */
+    updateUserSync(user: StatsigUser, options?: SyncUpdateOptions): StatsigUpdateDetails;
+    private _updateUserSyncImpl;
+    /**
+     * Asynchronously updates the user in the Statsig client by initially using cached values and then fetching the latest values from the network.
+     * When the latest values are fetched, they replace the cached values. If the promise returned by this method is not awaited,
+     * the client's state may shift from cached to updated network values during the session, potentially affecting consistency.
+     * This method is best used in scenarios where up-to-date configuration is critical and initial delays are acceptable.
+     *
+     * @param {StatsigUser} user - The new StatsigUser for which the client should update its internal state.
+     * @param {AsyncUpdateOptions} [options] - Optional. Additional options to customize the method call.
+     * @returns {Promise<void>} A promise that resolves once the client is fully updated with the latest values from the network or a timeout (if set) is hit.
+     * @see {@link updateUserSync} for the synchronous version of this method.
+     */
+    updateUserAsync(user: StatsigUser, options?: AsyncUpdateOptions): Promise<StatsigUpdateDetails>;
+    private _updateUserAsyncImpl;
+    /**
+     * Retrieves a synchronous context containing data currently being used by the SDK. Represented as a {@link PrecomputedEvaluationsContext} object.
+     *
+     * @returns {PrecomputedEvaluationsContext} The current synchronous context for the this StatsigClient instance.
+     */
+    getContext(): PrecomputedEvaluationsContext;
+    /**
+     * Retrieves the value of a feature gate for the current user, represented as a simple boolean.
+     *
+     * @param {string} name - The name of the feature gate to retrieve.
+     * @param {FeatureGateEvaluationOptions} [options] - Optional. Additional options to customize the method call.
+     * @returns {boolean} - The boolean value representing the gate's current evaluation results for the user.
+     */
+    checkGate(name: string, options?: FeatureGateEvaluationOptions): boolean;
+    /**
+     * Retrieves the value of a feature gate for the current user, represented as a {@link FeatureGate} object.
+     *
+     * @param {string} name - The name of the feature gate to retrieve.
+     * @param {FeatureGateEvaluationOptions} [options] - Optional. Additional options to customize the method call.
+     * @returns {FeatureGate} - The {@link FeatureGate} object representing the gate's current evaluation results for the user.
+     */
+    readonly getFeatureGate: (name: string, options?: import("@statsig/client-core").EvaluationOptionsCommon | undefined) => {
+        readonly name: string;
+        readonly ruleID: string;
+        readonly details: import("@statsig/client-core").EvaluationDetails;
+        readonly value: boolean;
+        readonly idType: string | null;
+        readonly __evaluation: import("@statsig/client-core").GateEvaluation | null;
+    };
+    /**
+     * Retrieves the value of a dynamic config for the current user.
+     *
+     * @param {string} name The name of the dynamic config to get.
+     * @param {DynamicConfigEvaluationOptions} [options] - Optional. Additional options to customize the method call.
+     * @returns {DynamicConfig} - The {@link DynamicConfig} object representing the dynamic configs's current evaluation results for the user.
+     */
+    readonly getDynamicConfig: (name: string, options?: import("@statsig/client-core").EvaluationOptionsCommon | undefined) => {
+        readonly name: string;
+        readonly value: Record<string, unknown>;
+        readonly ruleID: string;
+        readonly details: import("@statsig/client-core").EvaluationDetails;
+        readonly idType: string | null;
+        readonly __evaluation: {
+            id_type: string;
+            name: string;
+            rule_id: string;
+            secondary_exposures: string[] | import("@statsig/client-core").SecondaryExposure[];
+            value: Record<string, unknown>;
+            version?: string | undefined;
+            group_name?: string | undefined;
+            group: string;
+            is_device_based: boolean;
+            is_experiment_active?: boolean | undefined;
+            is_user_in_experiment?: boolean | undefined;
+            passed?: boolean | undefined;
+            is_in_layer?: boolean | undefined;
+            explicit_parameters?: string[] | undefined;
+        } | null;
+        readonly get: import("@statsig/client-core").TypedGet;
+    };
+    /**
+     * Retrieves the value of a experiment for the current user.
+     *
+     * @param {string} name The name of the experiment to get.
+     * @param {ExperimentEvaluationOptions} [options] - Optional. Additional options to customize the method call.
+     * @returns {Experiment} - The {@link Experiment} object representing the experiments's current evaluation results for the user.
+     */
+    readonly getExperiment: (name: string, options?: ExperimentEvaluationOptions | undefined) => {
+        readonly name: string;
+        readonly ruleID: string;
+        readonly details: import("@statsig/client-core").EvaluationDetails;
+        readonly value: Record<string, unknown>;
+        readonly groupName: string | null;
+        readonly idType: string | null;
+        readonly __evaluation: {
+            id_type: string;
+            name: string;
+            rule_id: string;
+            secondary_exposures: string[] | import("@statsig/client-core").SecondaryExposure[];
+            value: Record<string, unknown>;
+            version?: string | undefined;
+            group_name?: string | undefined;
+            group: string;
+            is_device_based: boolean;
+            is_experiment_active?: boolean | undefined;
+            is_user_in_experiment?: boolean | undefined;
+            passed?: boolean | undefined;
+            is_in_layer?: boolean | undefined;
+            explicit_parameters?: string[] | undefined;
+        } | null;
+        readonly get: import("@statsig/client-core").TypedGet;
+    };
+    /**
+     * Retrieves the list of all Dynamic Configs and Experiments for the current user.
+     *
+     * @returns {string[]} The list of all Dynamic Config and Experiment names for the current user. Note - these will be hashed unless you've disabled hashing.
+     * This is intended to be used for debugging.
+     */
+    readonly getConfigList: (name: string, options?: import("@statsig/client-core").AnyEvaluationOptions | undefined) => string[];
+    /**
+     * Retrieves the value of a layer for the current user.
+     *
+     * @param {string} name The name of the layer to get.
+     * @param {LayerEvaluationOptions} [options] - Optional. Additional options to customize the method call.
+     * @returns {Layer} - The {@link Layer} object representing the layers's current evaluation results for the user.
+     */
+    readonly getLayer: (name: string, options?: LayerEvaluationOptions | undefined) => {
+        readonly name: string;
+        readonly ruleID: string;
+        readonly details: import("@statsig/client-core").EvaluationDetails;
+        readonly groupName: string | null;
+        readonly __value: Record<string, unknown>;
+        readonly __evaluation: {
+            name: string;
+            rule_id: string;
+            secondary_exposures: string[] | import("@statsig/client-core").SecondaryExposure[];
+            value: Record<string, unknown>;
+            version?: string | undefined;
+            group_name?: string | undefined;
+            group: string;
+            is_device_based: boolean;
+            is_experiment_active?: boolean | undefined;
+            is_user_in_experiment?: boolean | undefined;
+            passed?: boolean | undefined;
+            is_in_layer?: boolean | undefined;
+            explicit_parameters: string[];
+            allocated_experiment_name: string;
+            undelegated_secondary_exposures?: string[] | import("@statsig/client-core").SecondaryExposure[] | undefined;
+            parameter_rule_ids?: Record<string, string> | undefined;
+        } | null;
+        get: import("@statsig/client-core").TypedGet;
+    };
+    /**
+     * Retrieves the value of a parameter store for the current user.
+     *
+     * @param {string} name The name of the parameter store to get.
+     * @param {ParameterStoreEvaluationOptions} [options] - Optional. Additional options to customize the method call.
+     * @returns {ParameterStore} - The {@link ParameterStore} object representing the parameter store's current mappings for the user.
+     */
+    readonly getParameterStore: (name: string, options?: import("@statsig/client-core").EvaluationOptionsCommon | undefined) => {
+        readonly name: string;
+        readonly details: import("@statsig/client-core").EvaluationDetails;
+        readonly get: import("@statsig/client-core").TypedGet;
+        readonly __configuration: import("@statsig/client-core").ParamStoreConfig | null;
+    };
+    /**
+     * Logs an event to the internal logging system. This function allows logging by either passing a fully formed event object or by specifying the event name with optional value and metadata.
+     *
+     * @param {StatsigEvent|string} eventOrName - The event object conforming to the StatsigEvent interface, or the name of the event as a string.
+     * @param {string|number} value - Optional. The value associated with the event, which can be a string or a number. This parameter is ignored if the first parameter is a StatsigEvent object.
+     * @param {Record<string, string>} metadata - Optional. A key-value record containing metadata about the event. This is also ignored if the first parameter is an event object.
+     */
+    logEvent(eventOrName: StatsigEvent | string, value?: string | number, metadata?: Record<string, string>): void;
+    /**
+     * Updates the user with analytics only metadata. This will override any existing analytics only metadata.
+     *
+     * @param {Record<string, string | number | boolean>} metadata - The metadata to add to the user.
+     */
+    updateUserWithAnalyticsOnlyMetadata(metadata: Record<string, string | number | boolean>): void;
+    protected _primeReadyRipcord(): void;
+    private _initializeAsyncImpl;
+    private _createErrorUpdateDetails;
+    private _finalizeUpdate;
+    private _runPostUpdate;
+    private _resetForUser;
+    private _configureUser;
+    private _getFeatureGateImpl;
+    private _getDynamicConfigImpl;
+    private _getExperimentImpl;
+    private _getConfigListImpl;
+    private _getLayerImpl;
+    private _getParameterStoreImpl;
+}
+export {};