@mangostudio/cli-darwin-arm64 0.1.0 → 0.1.1-canary.00a342c

package/cursor-sidecar/node_modules/@statsig/client-core/src/Diagnostics.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Diagnostics = void 0;
+const MARKER_MAP = new Map();
+const ACT_START = 'start';
+const ACT_END = 'end';
+const DIAGNOSTICS_EVENT = 'statsig::diagnostics';
+exports.Diagnostics = {
+    _getMarkers: (sdkKey) => {
+        return MARKER_MAP.get(sdkKey);
+    },
+    _markInitOverallStart: (sdkKey) => {
+        _addMarker(sdkKey, _createMarker({}, ACT_START, 'overall'));
+    },
+    _markInitOverallEnd: (sdkKey, success, evaluationDetails) => {
+        _addMarker(sdkKey, _createMarker({
+            success,
+            error: success
+                ? undefined
+                : { name: 'InitializeError', message: 'Failed to initialize' },
+            evaluationDetails,
+        }, ACT_END, 'overall'));
+    },
+    _markInitNetworkReqStart: (sdkKey, data) => {
+        _addMarker(sdkKey, _createMarker(data, ACT_START, 'initialize', 'network_request'));
+    },
+    _markInitNetworkReqEnd: (sdkKey, data) => {
+        _addMarker(sdkKey, _createMarker(data, ACT_END, 'initialize', 'network_request'));
+    },
+    _markInitProcessStart: (sdkKey) => {
+        _addMarker(sdkKey, _createMarker({}, ACT_START, 'initialize', 'process'));
+    },
+    _markInitProcessEnd: (sdkKey, data) => {
+        _addMarker(sdkKey, _createMarker(data, ACT_END, 'initialize', 'process'));
+    },
+    _clearMarkers: (sdkKey) => {
+        MARKER_MAP.delete(sdkKey);
+    },
+    _formatError(e) {
+        if (!(e && typeof e === 'object')) {
+            return;
+        }
+        return {
+            code: _safeGetField(e, 'code'),
+            name: _safeGetField(e, 'name'),
+            message: _safeGetField(e, 'message'),
+        };
+    },
+    _getDiagnosticsData(res, attempt, body, e) {
+        var _a;
+        return {
+            success: (res === null || res === void 0 ? void 0 : res.ok) === true,
+            statusCode: res === null || res === void 0 ? void 0 : res.status,
+            sdkRegion: (_a = res === null || res === void 0 ? void 0 : res.headers) === null || _a === void 0 ? void 0 : _a.get('x-statsig-region'),
+            isDelta: body.includes('"is_delta":true') === true ? true : undefined,
+            attempt,
+            error: exports.Diagnostics._formatError(e),
+        };
+    },
+    _enqueueDiagnosticsEvent(user, logger, sdk, options) {
+        const markers = exports.Diagnostics._getMarkers(sdk);
+        if (markers == null || markers.length <= 0) {
+            return -1;
+        }
+        const overallInitDuration = markers[markers.length - 1].timestamp - markers[0].timestamp;
+        exports.Diagnostics._clearMarkers(sdk);
+        const event = _makeDiagnosticsEvent(user, {
+            context: 'initialize',
+            markers: markers.slice(),
+            statsigOptions: options,
+        });
+        logger.enqueue(event);
+        return overallInitDuration;
+    },
+};
+function _createMarker(data, action, key, step) {
+    return Object.assign({ key: key, action: action, step: step, timestamp: Date.now() }, data);
+}
+function _makeDiagnosticsEvent(user, data) {
+    const latencyEvent = {
+        eventName: DIAGNOSTICS_EVENT,
+        user,
+        value: null,
+        metadata: data,
+        time: Date.now(),
+    };
+    return latencyEvent;
+}
+function _addMarker(sdkKey, marker) {
+    var _a;
+    const markers = (_a = MARKER_MAP.get(sdkKey)) !== null && _a !== void 0 ? _a : [];
+    markers.push(marker);
+    MARKER_MAP.set(sdkKey, markers);
+}
+function _safeGetField(data, field) {
+    if (field in data) {
+        return data[field];
+    }
+    return undefined;
+}

package/cursor-sidecar/node_modules/@statsig/client-core/src/DnsTxtQuery.d.ts

@@ -0,0 +1,2 @@
+import { NetworkArgs } from './NetworkConfig';
+export declare function _fetchTxtRecords(networkFunc: (url: string, args: NetworkArgs) => Promise<Response>): Promise<string[]>;

package/cursor-sidecar/node_modules/@statsig/client-core/src/DnsTxtQuery.js

@@ -0,0 +1,63 @@
+"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 });
+exports._fetchTxtRecords = void 0;
+// See example: https://github.com/statsig-io/private-js-client-monorepo/pull/340
+const FEATURE_ASSETS_DNS_QUERY = new Uint8Array([
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d,
+    0x66, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x61, 0x73, 0x73, 0x65, 0x74, 0x73,
+    0x03, 0x6f, 0x72, 0x67, 0x00, 0x00, 0x10, 0x00, 0x01,
+]);
+const DNS_QUERY_ENDPOINT = 'https://cloudflare-dns.com/dns-query';
+const DOMAIN_CHARS = [
+    'i', // initialize
+    'e', // events
+    'd', // dcs
+];
+const MAX_START_LOOKUP = 200;
+function _fetchTxtRecords(networkFunc) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield networkFunc(DNS_QUERY_ENDPOINT, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/dns-message',
+                Accept: 'application/dns-message',
+            },
+            body: FEATURE_ASSETS_DNS_QUERY,
+        });
+        if (!response.ok) {
+            const err = new Error('Failed to fetch TXT records from DNS');
+            err.name = 'DnsTxtFetchError';
+            throw err;
+        }
+        const data = yield response.arrayBuffer();
+        const bytes = new Uint8Array(data);
+        return _parseDnsResponse(bytes);
+    });
+}
+exports._fetchTxtRecords = _fetchTxtRecords;
+function _parseDnsResponse(input) {
+    // loop until we find the first valid domain char. One of [i=, e=, d=]
+    const start = input.findIndex((byte, index) => index < MAX_START_LOOKUP &&
+        String.fromCharCode(byte) === '=' &&
+        DOMAIN_CHARS.includes(String.fromCharCode(input[index - 1])));
+    if (start === -1) {
+        const err = new Error('Failed to parse TXT records from DNS');
+        err.name = 'DnsTxtParseError';
+        throw err;
+    }
+    // decode the remaining bytes as a string
+    let result = '';
+    for (let i = start - 1; i < input.length; i++) {
+        result += String.fromCharCode(input[i]);
+    }
+    return result.split(',');
+}

package/cursor-sidecar/node_modules/@statsig/client-core/src/DownloadConfigSpecsResponse.d.ts

@@ -0,0 +1,61 @@
+import { ParamStoreConfig } from './ParamStoreTypes';
+import { StatsigUser } from './StatsigUser';
+export type SpecCondition = {
+    type: string;
+    targetValue: unknown;
+    operator: string | null;
+    field: string | null;
+    additionalValues: Record<string, unknown> | null;
+    idType: string;
+};
+export type SpecRule = {
+    name: string;
+    passPercentage: number;
+    conditions: SpecCondition[];
+    returnValue: unknown;
+    id: string;
+    salt: string;
+    idType: string;
+    configDelegate: string | null;
+    isExperimentGroup?: boolean;
+    groupName?: string;
+};
+export type Spec = {
+    name: string;
+    type: string;
+    salt: string;
+    defaultValue: unknown;
+    enabled: boolean;
+    idType: string;
+    rules: SpecRule[];
+    entity: string;
+    explicitParameters: string[] | null;
+    hasSharedParams: boolean;
+    isActive?: boolean;
+    targetAppIDs?: string[];
+    version?: number;
+};
+export type ParamStore = {
+    targetAppIDs?: string[];
+    parameters: ParamStoreConfig;
+};
+export type DownloadConfigSpecsResponse = {
+    feature_gates: Spec[];
+    dynamic_configs: Spec[];
+    layer_configs: Spec[];
+    param_stores?: Record<string, ParamStore>;
+    layers?: Record<string, string[]>;
+    time: number;
+    has_updates: boolean;
+    sdkInfo?: Record<string, string>;
+    user?: StatsigUser;
+    default_environment?: string;
+    sdk_keys_to_app_ids?: Record<string, string>;
+    hashed_sdk_keys_to_app_ids?: Record<string, string>;
+    hashed_sdk_keys_to_entities?: Record<string, {
+        gates: string[];
+        configs: string[];
+        experiments: string[];
+    }>;
+    app_id?: string;
+};

package/cursor-sidecar/node_modules/@statsig/client-core/src/DownloadConfigSpecsResponse.js

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

package/cursor-sidecar/node_modules/@statsig/client-core/src/ErrorBoundary.d.ts

@@ -0,0 +1,17 @@
+import { StatsigClientEmitEventFunc } from './StatsigClientBase';
+import { AnyStatsigOptions } from './StatsigOptionsCommon';
+export declare const EXCEPTION_ENDPOINT = "https://statsigapi.net/v1/sdk_exception";
+export declare class ErrorBoundary {
+    private _sdkKey;
+    private _options;
+    private _emitter?;
+    private _lastSeenError?;
+    private _seen;
+    constructor(_sdkKey: string, _options: AnyStatsigOptions | null, _emitter?: StatsigClientEmitEventFunc | undefined, _lastSeenError?: Error | undefined);
+    wrap(instance: unknown, namePrefix?: string): void;
+    logError(tag: string, error: unknown): void;
+    getLastSeenErrorAndReset(): Error | null;
+    attachErrorIfNoneExists(error: unknown): void;
+    private _capture;
+    private _onError;
+}

package/cursor-sidecar/node_modules/@statsig/client-core/src/ErrorBoundary.js

@@ -0,0 +1,197 @@
+"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 });
+exports.ErrorBoundary = exports.EXCEPTION_ENDPOINT = void 0;
+const Log_1 = require("./Log");
+const SDKType_1 = require("./SDKType");
+const StatsigMetadata_1 = require("./StatsigMetadata");
+exports.EXCEPTION_ENDPOINT = 'https://statsigapi.net/v1/sdk_exception';
+const UNKNOWN_ERROR = '[Statsig] UnknownError';
+class ErrorBoundary {
+    constructor(_sdkKey, _options, _emitter, _lastSeenError) {
+        this._sdkKey = _sdkKey;
+        this._options = _options;
+        this._emitter = _emitter;
+        this._lastSeenError = _lastSeenError;
+        this._seen = new Set();
+    }
+    wrap(instance, namePrefix) {
+        try {
+            const obj = instance;
+            _getAllInstanceMethodNames(obj).forEach((name) => {
+                const original = obj[name];
+                if ('$EB' in original) {
+                    return;
+                }
+                obj[name] = (...args) => {
+                    return this._capture(namePrefix ? `${namePrefix}:${name}` : name, () => original.apply(instance, args));
+                };
+                obj[name].$EB = true;
+            });
+        }
+        catch (err) {
+            this._onError('eb:wrap', err);
+        }
+    }
+    logError(tag, error) {
+        this._onError(tag, error);
+    }
+    getLastSeenErrorAndReset() {
+        const tempError = this._lastSeenError;
+        this._lastSeenError = undefined;
+        return tempError !== null && tempError !== void 0 ? tempError : null;
+    }
+    attachErrorIfNoneExists(error) {
+        if (this._lastSeenError) {
+            return;
+        }
+        this._lastSeenError = _resolveError(error);
+    }
+    _capture(tag, task) {
+        try {
+            const res = task();
+            if (res && res instanceof Promise) {
+                return res.catch((err) => this._onError(tag, err));
+            }
+            return res;
+        }
+        catch (error) {
+            this._onError(tag, error);
+            return null;
+        }
+    }
+    _onError(tag, error) {
+        try {
+            Log_1.Log.warn(`Caught error in ${tag}`, { error });
+            const impl = () => __awaiter(this, void 0, void 0, function* () {
+                var _a, _b, _c, _d, _e, _f, _g;
+                const unwrapped = (error ? error : Error(UNKNOWN_ERROR));
+                const isError = unwrapped instanceof Error;
+                const name = isError ? unwrapped.name : 'No Name';
+                const resolvedError = _resolveError(unwrapped);
+                this._lastSeenError = resolvedError;
+                if (this._seen.has(name)) {
+                    return;
+                }
+                this._seen.add(name);
+                if ((_b = (_a = this._options) === null || _a === void 0 ? void 0 : _a.networkConfig) === null || _b === void 0 ? void 0 : _b.preventAllNetworkTraffic) {
+                    (_c = this._emitter) === null || _c === void 0 ? void 0 : _c.call(this, {
+                        name: 'error',
+                        error,
+                        tag,
+                    });
+                    return;
+                }
+                const sdkType = SDKType_1.SDKType._get(this._sdkKey);
+                const statsigMetadata = StatsigMetadata_1.StatsigMetadataProvider.get();
+                const info = isError ? unwrapped.stack : _getDescription(unwrapped);
+                const body = Object.assign({ tag, exception: name, info, statsigOptions: _getStatsigOptionLoggingCopy(this._options) }, Object.assign(Object.assign({}, statsigMetadata), { sdkType }));
+                const func = (_f = (_e = (_d = this._options) === null || _d === void 0 ? void 0 : _d.networkConfig) === null || _e === void 0 ? void 0 : _e.networkOverrideFunc) !== null && _f !== void 0 ? _f : fetch;
+                yield func(exports.EXCEPTION_ENDPOINT, {
+                    method: 'POST',
+                    headers: {
+                        'STATSIG-API-KEY': this._sdkKey,
+                        'STATSIG-SDK-TYPE': String(sdkType),
+                        'STATSIG-SDK-VERSION': String(statsigMetadata.sdkVersion),
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify(body),
+                });
+                (_g = this._emitter) === null || _g === void 0 ? void 0 : _g.call(this, {
+                    name: 'error',
+                    error,
+                    tag,
+                });
+            });
+            impl()
+                .then(() => {
+                /* noop */
+            })
+                .catch(() => {
+                /* noop */
+            });
+        }
+        catch (_error) {
+            /* noop */
+        }
+    }
+}
+exports.ErrorBoundary = ErrorBoundary;
+function _resolveError(error) {
+    if (error instanceof Error) {
+        return error;
+    }
+    else if (typeof error === 'string') {
+        return new Error(error);
+    }
+    else {
+        return new Error('An unknown error occurred.');
+    }
+}
+function _getDescription(obj) {
+    try {
+        return JSON.stringify(obj);
+    }
+    catch (_a) {
+        return UNKNOWN_ERROR;
+    }
+}
+function _getAllInstanceMethodNames(instance) {
+    const names = new Set();
+    let proto = Object.getPrototypeOf(instance);
+    while (proto && proto !== Object.prototype) {
+        Object.getOwnPropertyNames(proto)
+            .filter((prop) => typeof (proto === null || proto === void 0 ? void 0 : proto[prop]) === 'function')
+            .forEach((name) => names.add(name));
+        proto = Object.getPrototypeOf(proto);
+    }
+    return Array.from(names);
+}
+function _getStatsigOptionLoggingCopy(options) {
+    if (!options) {
+        return {};
+    }
+    const loggingCopy = {};
+    Object.keys(options).forEach((key) => {
+        const option = key;
+        const value = options[option];
+        const valueType = typeof value;
+        switch (valueType) {
+            case 'number':
+            case 'bigint':
+            case 'boolean':
+                loggingCopy[String(option)] = value;
+                break;
+            case 'string':
+                if (value.length < 50) {
+                    loggingCopy[String(option)] = value;
+                }
+                else {
+                    loggingCopy[String(option)] = 'set';
+                }
+                break;
+            case 'object':
+                if (option === 'environment') {
+                    loggingCopy['environment'] = value;
+                }
+                else if (option === 'networkConfig') {
+                    loggingCopy['networkConfig'] = value;
+                }
+                else {
+                    loggingCopy[String(option)] = value != null ? 'set' : 'unset';
+                }
+                break;
+            default:
+            // Ignore other fields
+        }
+    });
+    return loggingCopy;
+}

package/cursor-sidecar/node_modules/@statsig/client-core/src/EvaluationOptions.d.ts

@@ -0,0 +1,30 @@
+export type EvaluationOptionsCommon = {
+    /**
+     * Prevents an exposure log being created for this check.
+     *
+     * default: `false`
+     */
+    disableExposureLog?: boolean;
+};
+export type FeatureGateEvaluationOptions = EvaluationOptionsCommon & {};
+export type DynamicConfigEvaluationOptions = EvaluationOptionsCommon & {};
+export type ExperimentEvaluationOptions = EvaluationOptionsCommon & {
+    /**
+     * Provide a map of values to be used across checks
+     *
+     * @requires {@link @statsig/js-user-persisted-storage}
+     * @see {@link https://docs.statsig.com/client/concepts/persistent_assignment#example-usage}
+     */
+    userPersistedValues?: unknown;
+};
+export type LayerEvaluationOptions = EvaluationOptionsCommon & {
+    /**
+     * Provide a map of values to be used across checks
+     *
+     * @requires {@link @statsig/js-user-persisted-storage}
+     * @see {@link https://docs.statsig.com/client/concepts/persistent_assignment#example-usage}
+     */
+    userPersistedValues?: unknown;
+};
+export type ParameterStoreEvaluationOptions = EvaluationOptionsCommon & {};
+export type AnyEvaluationOptions = FeatureGateEvaluationOptions | DynamicConfigEvaluationOptions | ExperimentEvaluationOptions | LayerEvaluationOptions | ParameterStoreEvaluationOptions;

package/cursor-sidecar/node_modules/@statsig/client-core/src/EvaluationOptions.js

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

package/cursor-sidecar/node_modules/@statsig/client-core/src/EvaluationTypes.d.ts

@@ -0,0 +1,49 @@
+import { ParamStoreConfig } from './ParamStoreTypes';
+import { BootstrapMetadata } from './StatsigEvent';
+import { Flatten } from './TypingUtils';
+type EvaluationBase<T> = {
+    id_type: string;
+    name: string;
+    rule_id: string;
+    secondary_exposures: SecondaryExposure[] | string[];
+    value: T;
+    version?: string;
+};
+export type SecondaryExposure = {
+    gate: string;
+    gateValue: string;
+    ruleID: string;
+};
+export type GateEvaluation = EvaluationBase<boolean>;
+export type ExperimentEvaluation = Flatten<EvaluationBase<Record<string, unknown>> & {
+    group_name?: string;
+    group: string;
+    id_type: string;
+    is_device_based: boolean;
+    is_experiment_active?: boolean;
+    is_user_in_experiment?: boolean;
+    passed?: boolean;
+    is_in_layer?: boolean;
+    explicit_parameters?: string[];
+}>;
+export type DynamicConfigEvaluation = ExperimentEvaluation;
+export type LayerEvaluation = Flatten<Omit<ExperimentEvaluation, 'id_type'> & {
+    allocated_experiment_name: string;
+    explicit_parameters: string[];
+    undelegated_secondary_exposures?: SecondaryExposure[] | string[];
+    parameter_rule_ids?: Record<string, string>;
+}>;
+export type AnyEvaluation = GateEvaluation | ExperimentEvaluation | DynamicConfigEvaluation | LayerEvaluation;
+export type EvaluationDetails = {
+    reason: string;
+    lcut?: number;
+    receivedAt?: number;
+    warnings?: StatsigWarnings[];
+    bootstrapMetadata?: BootstrapMetadata;
+};
+export type DetailedStoreResult<T extends AnyEvaluation | ParamStoreConfig> = {
+    result: T | null;
+    details: EvaluationDetails;
+};
+export type StatsigWarnings = 'PartialUserMatch' | 'StableIDMismatch' | 'MultipleInitializations' | 'NoCachedValues';
+export {};

package/cursor-sidecar/node_modules/@statsig/client-core/src/EvaluationTypes.js

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

package/cursor-sidecar/node_modules/@statsig/client-core/src/EvaluationTypesV2.d.ts

@@ -0,0 +1,30 @@
+export type GateEvaluationV2 = {
+    v?: true;
+    r?: string | null;
+    i?: string;
+    s?: string[];
+};
+export type ExperimentEvaluationV2 = {
+    r: string;
+    v: string;
+    gn?: string | null;
+    i?: string;
+    s?: string[];
+    ue?: true;
+    ea?: true;
+    p?: true;
+};
+export type DynamicConfigEvaluationV2 = ExperimentEvaluationV2;
+export type LayerEvaluationV2 = {
+    r: string;
+    v: string;
+    gn?: string | null;
+    i?: string;
+    s?: string[];
+    us?: string[];
+    ue?: true;
+    ea?: true;
+    ep?: string[];
+    ae?: string;
+    pr?: Record<string, string>;
+};

package/cursor-sidecar/node_modules/@statsig/client-core/src/EvaluationTypesV2.js

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

package/cursor-sidecar/node_modules/@statsig/client-core/src/EventBatch.d.ts

@@ -0,0 +1,8 @@
+import { StatsigEventInternal } from './StatsigEvent';
+export declare class EventBatch {
+    attempts: number;
+    readonly events: StatsigEventInternal[];
+    readonly createdAt: number;
+    constructor(events: StatsigEventInternal[]);
+    incrementAttempts(): void;
+}

package/cursor-sidecar/node_modules/@statsig/client-core/src/EventBatch.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventBatch = void 0;
+class EventBatch {
+    constructor(events) {
+        this.attempts = 0;
+        this.createdAt = Date.now();
+        this.events = events;
+    }
+    incrementAttempts() {
+        this.attempts++;
+    }
+}
+exports.EventBatch = EventBatch;

package/cursor-sidecar/node_modules/@statsig/client-core/src/EventLogger.d.ts

@@ -0,0 +1,48 @@
+import { NetworkCore } from './NetworkCore';
+import { StatsigClientEmitEventFunc } from './StatsigClientBase';
+import { StatsigEventInternal } from './StatsigEvent';
+import { LogEventCompressionMode, LoggingEnabledOption, NetworkConfigCommon, StatsigOptionsCommon } from './StatsigOptionsCommon';
+export declare class EventLogger {
+    private _sdkKey;
+    private _emitter;
+    private _network;
+    private _options;
+    private _queue;
+    private _flushIntervalId;
+    private _lastExposureTimeMap;
+    private _nonExposedChecks;
+    private _maxQueueSize;
+    private _hasRunQuickFlush;
+    private _creationTime;
+    private _loggingEnabled;
+    private _logEventUrlConfig;
+    private static _safeFlushAndForget;
+    private static _safeRetryFailedLogs;
+    constructor(_sdkKey: string, _emitter: StatsigClientEmitEventFunc, _network: NetworkCore, _options: StatsigOptionsCommon<NetworkConfigCommon> | null);
+    setLogEventCompressionMode(mode: LogEventCompressionMode): void;
+    setLoggingEnabled(loggingEnabled: LoggingEnabledOption): void;
+    enqueue(event: StatsigEventInternal): void;
+    incrementNonExposureCount(name: string): void;
+    reset(): void;
+    start(): void;
+    stop(): Promise<void>;
+    flush(): Promise<void>;
+    /**
+     * We 'Quick Flush' following the very first event enqueued
+     * within the quick flush window
+     */
+    private _quickFlushIfNeeded;
+    private _shouldLogEvent;
+    private _sendEvents;
+    private _sendEventsViaPost;
+    private _sendEventsViaBeacon;
+    private _getRequestData;
+    private _saveFailedLogsToStorage;
+    private _getFailedLogsFromStorage;
+    private _retryFailedLogs;
+    private _getStorageKey;
+    private _normalizeAndAppendEvent;
+    private _appendAndResetNonExposedChecks;
+    private _getCurrentPageUrl;
+    private _startBackgroundFlushInterval;
+}