@posthog/browser-common 0.9.2 → 0.9.3

package/dist/config.js

@@ -27,7 +27,7 @@ var __webpack_require__ = {};
 })();
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
-const packageVersion = "0.9.2";
+const packageVersion = "0.9.3";
 const Config = {
     DEBUG: false,
     LIB_VERSION: packageVersion,

package/dist/config.mjs

@@ -1,4 +1,4 @@
-const packageVersion = "0.9.2";
+const packageVersion = "0.9.3";
 const Config = {
     DEBUG: false,
     LIB_VERSION: packageVersion,

package/dist/constants.d.ts

@@ -1,3 +1,19 @@
 export declare const TOOLBAR_ID = "__POSTHOG_TOOLBAR__";
 export declare const TOOLBAR_CONTAINER_CLASS = "toolbar-global-fade-container";
 export declare const SDK_DIST_CHANNEL = "$sdk_dist_channel";
+export declare const PERSISTENCE_EARLY_ACCESS_FEATURES = "$early_access_features";
+export declare const PERSISTENCE_ACTIVE_FEATURE_FLAGS = "$active_feature_flags";
+export declare const PERSISTENCE_FEATURE_FLAG_DETAILS = "$feature_flag_details";
+export declare const PERSISTENCE_FEATURE_FLAG_ERRORS = "$feature_flag_errors";
+export declare const PERSISTENCE_FEATURE_FLAG_EVALUATED_AT = "$feature_flag_evaluated_at";
+export declare const PERSISTENCE_FEATURE_FLAG_REQUEST_ID = "$feature_flag_request_id";
+export declare const PERSISTENCE_MINIMAL_FLAG_CALLED_EVENTS = "$minimal_flag_called_events";
+export declare const ENABLED_FEATURE_FLAGS = "$enabled_feature_flags";
+export declare const STORED_GROUP_PROPERTIES_KEY = "$stored_group_properties";
+export declare const STORED_PERSON_PROPERTIES_KEY = "$stored_person_properties";
+export declare const FLAG_CALL_REPORTED = "$flag_call_reported";
+export declare const FLAG_CALL_REPORTED_SESSION_ID = "$flag_call_reported_session_id";
+export declare const PERSISTENCE_FEATURE_FLAG_PAYLOADS = "$feature_flag_payloads";
+export declare const PERSISTENCE_OVERRIDE_FEATURE_FLAGS = "$override_feature_flags";
+export declare const PERSISTENCE_OVERRIDE_FEATURE_FLAG_PAYLOADS = "$override_feature_flag_payloads";
+export declare const DOM_EVENT_VISIBILITYCHANGE = "visibilitychange";

package/dist/constants.js

@@ -30,16 +30,80 @@ __webpack_require__.r(__webpack_exports__);
 const TOOLBAR_ID = '__POSTHOG_TOOLBAR__';
 const TOOLBAR_CONTAINER_CLASS = 'toolbar-global-fade-container';
 const SDK_DIST_CHANNEL = '$sdk_dist_channel';
+const PERSISTENCE_EARLY_ACCESS_FEATURES = '$early_access_features';
+const PERSISTENCE_ACTIVE_FEATURE_FLAGS = '$active_feature_flags';
+const PERSISTENCE_FEATURE_FLAG_DETAILS = '$feature_flag_details';
+const PERSISTENCE_FEATURE_FLAG_ERRORS = '$feature_flag_errors';
+const PERSISTENCE_FEATURE_FLAG_EVALUATED_AT = '$feature_flag_evaluated_at';
+const PERSISTENCE_FEATURE_FLAG_REQUEST_ID = '$feature_flag_request_id';
+const PERSISTENCE_MINIMAL_FLAG_CALLED_EVENTS = '$minimal_flag_called_events';
+const ENABLED_FEATURE_FLAGS = '$enabled_feature_flags';
+const STORED_GROUP_PROPERTIES_KEY = '$stored_group_properties';
+const STORED_PERSON_PROPERTIES_KEY = '$stored_person_properties';
+const FLAG_CALL_REPORTED = '$flag_call_reported';
+const FLAG_CALL_REPORTED_SESSION_ID = '$flag_call_reported_session_id';
+const PERSISTENCE_FEATURE_FLAG_PAYLOADS = '$feature_flag_payloads';
+const PERSISTENCE_OVERRIDE_FEATURE_FLAGS = '$override_feature_flags';
+const PERSISTENCE_OVERRIDE_FEATURE_FLAG_PAYLOADS = '$override_feature_flag_payloads';
+const DOM_EVENT_VISIBILITYCHANGE = 'visibilitychange';
 __webpack_require__.d(__webpack_exports__, {}, {
+    DOM_EVENT_VISIBILITYCHANGE: DOM_EVENT_VISIBILITYCHANGE,
+    ENABLED_FEATURE_FLAGS: ENABLED_FEATURE_FLAGS,
+    FLAG_CALL_REPORTED: FLAG_CALL_REPORTED,
+    FLAG_CALL_REPORTED_SESSION_ID: FLAG_CALL_REPORTED_SESSION_ID,
+    PERSISTENCE_ACTIVE_FEATURE_FLAGS: PERSISTENCE_ACTIVE_FEATURE_FLAGS,
+    PERSISTENCE_EARLY_ACCESS_FEATURES: PERSISTENCE_EARLY_ACCESS_FEATURES,
+    PERSISTENCE_FEATURE_FLAG_DETAILS: PERSISTENCE_FEATURE_FLAG_DETAILS,
+    PERSISTENCE_FEATURE_FLAG_ERRORS: PERSISTENCE_FEATURE_FLAG_ERRORS,
+    PERSISTENCE_FEATURE_FLAG_EVALUATED_AT: PERSISTENCE_FEATURE_FLAG_EVALUATED_AT,
+    PERSISTENCE_FEATURE_FLAG_PAYLOADS: PERSISTENCE_FEATURE_FLAG_PAYLOADS,
+    PERSISTENCE_FEATURE_FLAG_REQUEST_ID: PERSISTENCE_FEATURE_FLAG_REQUEST_ID,
+    PERSISTENCE_MINIMAL_FLAG_CALLED_EVENTS: PERSISTENCE_MINIMAL_FLAG_CALLED_EVENTS,
+    PERSISTENCE_OVERRIDE_FEATURE_FLAGS: PERSISTENCE_OVERRIDE_FEATURE_FLAGS,
+    PERSISTENCE_OVERRIDE_FEATURE_FLAG_PAYLOADS: PERSISTENCE_OVERRIDE_FEATURE_FLAG_PAYLOADS,
     SDK_DIST_CHANNEL: SDK_DIST_CHANNEL,
+    STORED_GROUP_PROPERTIES_KEY: STORED_GROUP_PROPERTIES_KEY,
+    STORED_PERSON_PROPERTIES_KEY: STORED_PERSON_PROPERTIES_KEY,
     TOOLBAR_CONTAINER_CLASS: TOOLBAR_CONTAINER_CLASS,
     TOOLBAR_ID: TOOLBAR_ID
 });
+exports.DOM_EVENT_VISIBILITYCHANGE = __webpack_exports__.DOM_EVENT_VISIBILITYCHANGE;
+exports.ENABLED_FEATURE_FLAGS = __webpack_exports__.ENABLED_FEATURE_FLAGS;
+exports.FLAG_CALL_REPORTED = __webpack_exports__.FLAG_CALL_REPORTED;
+exports.FLAG_CALL_REPORTED_SESSION_ID = __webpack_exports__.FLAG_CALL_REPORTED_SESSION_ID;
+exports.PERSISTENCE_ACTIVE_FEATURE_FLAGS = __webpack_exports__.PERSISTENCE_ACTIVE_FEATURE_FLAGS;
+exports.PERSISTENCE_EARLY_ACCESS_FEATURES = __webpack_exports__.PERSISTENCE_EARLY_ACCESS_FEATURES;
+exports.PERSISTENCE_FEATURE_FLAG_DETAILS = __webpack_exports__.PERSISTENCE_FEATURE_FLAG_DETAILS;
+exports.PERSISTENCE_FEATURE_FLAG_ERRORS = __webpack_exports__.PERSISTENCE_FEATURE_FLAG_ERRORS;
+exports.PERSISTENCE_FEATURE_FLAG_EVALUATED_AT = __webpack_exports__.PERSISTENCE_FEATURE_FLAG_EVALUATED_AT;
+exports.PERSISTENCE_FEATURE_FLAG_PAYLOADS = __webpack_exports__.PERSISTENCE_FEATURE_FLAG_PAYLOADS;
+exports.PERSISTENCE_FEATURE_FLAG_REQUEST_ID = __webpack_exports__.PERSISTENCE_FEATURE_FLAG_REQUEST_ID;
+exports.PERSISTENCE_MINIMAL_FLAG_CALLED_EVENTS = __webpack_exports__.PERSISTENCE_MINIMAL_FLAG_CALLED_EVENTS;
+exports.PERSISTENCE_OVERRIDE_FEATURE_FLAGS = __webpack_exports__.PERSISTENCE_OVERRIDE_FEATURE_FLAGS;
+exports.PERSISTENCE_OVERRIDE_FEATURE_FLAG_PAYLOADS = __webpack_exports__.PERSISTENCE_OVERRIDE_FEATURE_FLAG_PAYLOADS;
 exports.SDK_DIST_CHANNEL = __webpack_exports__.SDK_DIST_CHANNEL;
+exports.STORED_GROUP_PROPERTIES_KEY = __webpack_exports__.STORED_GROUP_PROPERTIES_KEY;
+exports.STORED_PERSON_PROPERTIES_KEY = __webpack_exports__.STORED_PERSON_PROPERTIES_KEY;
 exports.TOOLBAR_CONTAINER_CLASS = __webpack_exports__.TOOLBAR_CONTAINER_CLASS;
 exports.TOOLBAR_ID = __webpack_exports__.TOOLBAR_ID;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DOM_EVENT_VISIBILITYCHANGE",
+    "ENABLED_FEATURE_FLAGS",
+    "FLAG_CALL_REPORTED",
+    "FLAG_CALL_REPORTED_SESSION_ID",
+    "PERSISTENCE_ACTIVE_FEATURE_FLAGS",
+    "PERSISTENCE_EARLY_ACCESS_FEATURES",
+    "PERSISTENCE_FEATURE_FLAG_DETAILS",
+    "PERSISTENCE_FEATURE_FLAG_ERRORS",
+    "PERSISTENCE_FEATURE_FLAG_EVALUATED_AT",
+    "PERSISTENCE_FEATURE_FLAG_PAYLOADS",
+    "PERSISTENCE_FEATURE_FLAG_REQUEST_ID",
+    "PERSISTENCE_MINIMAL_FLAG_CALLED_EVENTS",
+    "PERSISTENCE_OVERRIDE_FEATURE_FLAGS",
+    "PERSISTENCE_OVERRIDE_FEATURE_FLAG_PAYLOADS",
     "SDK_DIST_CHANNEL",
+    "STORED_GROUP_PROPERTIES_KEY",
+    "STORED_PERSON_PROPERTIES_KEY",
     "TOOLBAR_CONTAINER_CLASS",
     "TOOLBAR_ID"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];

package/dist/constants.mjs

@@ -1,4 +1,20 @@
 const TOOLBAR_ID = '__POSTHOG_TOOLBAR__';
 const TOOLBAR_CONTAINER_CLASS = 'toolbar-global-fade-container';
 const SDK_DIST_CHANNEL = '$sdk_dist_channel';
-export { SDK_DIST_CHANNEL, TOOLBAR_CONTAINER_CLASS, TOOLBAR_ID };
+const PERSISTENCE_EARLY_ACCESS_FEATURES = '$early_access_features';
+const PERSISTENCE_ACTIVE_FEATURE_FLAGS = '$active_feature_flags';
+const PERSISTENCE_FEATURE_FLAG_DETAILS = '$feature_flag_details';
+const PERSISTENCE_FEATURE_FLAG_ERRORS = '$feature_flag_errors';
+const PERSISTENCE_FEATURE_FLAG_EVALUATED_AT = '$feature_flag_evaluated_at';
+const PERSISTENCE_FEATURE_FLAG_REQUEST_ID = '$feature_flag_request_id';
+const PERSISTENCE_MINIMAL_FLAG_CALLED_EVENTS = '$minimal_flag_called_events';
+const ENABLED_FEATURE_FLAGS = '$enabled_feature_flags';
+const STORED_GROUP_PROPERTIES_KEY = '$stored_group_properties';
+const STORED_PERSON_PROPERTIES_KEY = '$stored_person_properties';
+const FLAG_CALL_REPORTED = '$flag_call_reported';
+const FLAG_CALL_REPORTED_SESSION_ID = '$flag_call_reported_session_id';
+const PERSISTENCE_FEATURE_FLAG_PAYLOADS = '$feature_flag_payloads';
+const PERSISTENCE_OVERRIDE_FEATURE_FLAGS = '$override_feature_flags';
+const PERSISTENCE_OVERRIDE_FEATURE_FLAG_PAYLOADS = '$override_feature_flag_payloads';
+const DOM_EVENT_VISIBILITYCHANGE = 'visibilitychange';
+export { DOM_EVENT_VISIBILITYCHANGE, ENABLED_FEATURE_FLAGS, FLAG_CALL_REPORTED, FLAG_CALL_REPORTED_SESSION_ID, PERSISTENCE_ACTIVE_FEATURE_FLAGS, PERSISTENCE_EARLY_ACCESS_FEATURES, PERSISTENCE_FEATURE_FLAG_DETAILS, PERSISTENCE_FEATURE_FLAG_ERRORS, PERSISTENCE_FEATURE_FLAG_EVALUATED_AT, PERSISTENCE_FEATURE_FLAG_PAYLOADS, PERSISTENCE_FEATURE_FLAG_REQUEST_ID, PERSISTENCE_MINIMAL_FLAG_CALLED_EVENTS, PERSISTENCE_OVERRIDE_FEATURE_FLAGS, PERSISTENCE_OVERRIDE_FEATURE_FLAG_PAYLOADS, SDK_DIST_CHANNEL, STORED_GROUP_PROPERTIES_KEY, STORED_PERSON_PROPERTIES_KEY, TOOLBAR_CONTAINER_CLASS, TOOLBAR_ID };

package/dist/feature-flags-config.d.ts

@@ -0,0 +1,23 @@
+import type { JsonType } from '@posthog/types';
+import type { Compression } from './types/compression';
+export interface FeatureFlagsConfig {
+    readonly bootstrap: {
+        readonly featureFlags?: Readonly<Record<string, string | boolean>>;
+        readonly featureFlagPayloads?: Readonly<Record<string, JsonType>>;
+    };
+    readonly remoteRequestsDisabled: boolean;
+    readonly featureFlagsDisabled: boolean;
+    readonly onlyEvaluateSurveyFeatureFlags: boolean;
+    readonly deduplicateCallsPerSession: boolean;
+    readonly cacheTtlMs?: number;
+    readonly refreshIntervalMs?: number;
+    readonly idleRefreshBackoff: boolean;
+    readonly requestTimeoutMs: number;
+    readonly requestMaxRetries?: number;
+    readonly compression?: Compression | 'best-available';
+    readonly evaluationContexts: readonly string[];
+    readonly flagKeys?: readonly string[];
+}
+export interface FeatureFlagsConfigSource {
+    get(): Readonly<FeatureFlagsConfig>;
+}

package/dist/feature-flags-config.js

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/feature-flags-config.mjs

@@ -0,0 +1 @@
+export { };

package/dist/feature-flags.d.ts

@@ -0,0 +1,329 @@
+import type { Client } from './client';
+import type { Extension } from './extension';
+import type { FlagsResponse } from './types/feature-flags';
+import type { FeatureFlagsCallback, EarlyAccessFeatureCallback, Properties, JsonType, EarlyAccessFeature, RemoteConfigFeatureFlagCallback, EarlyAccessFeatureStage, FeatureFlagDetail, FeatureFlagResult, FeatureFlagOptions, IsFeatureEnabledOptions, OverrideFeatureFlagsOptions } from '@posthog/types';
+import type { FeatureFlagsConfigSource } from './feature-flags-config';
+import { PERSISTENCE_EARLY_ACCESS_FEATURES, PERSISTENCE_ACTIVE_FEATURE_FLAGS, PERSISTENCE_FEATURE_FLAG_DETAILS, PERSISTENCE_FEATURE_FLAG_ERRORS, PERSISTENCE_FEATURE_FLAG_EVALUATED_AT, PERSISTENCE_FEATURE_FLAG_REQUEST_ID, PERSISTENCE_MINIMAL_FLAG_CALLED_EVENTS, ENABLED_FEATURE_FLAGS, STORED_GROUP_PROPERTIES_KEY, STORED_PERSON_PROPERTIES_KEY, FLAG_CALL_REPORTED, FLAG_CALL_REPORTED_SESSION_ID, PERSISTENCE_FEATURE_FLAG_PAYLOADS, PERSISTENCE_OVERRIDE_FEATURE_FLAGS, PERSISTENCE_OVERRIDE_FEATURE_FLAG_PAYLOADS } from './constants';
+import { type Logger } from '@posthog/core';
+type FeatureFlagsState = {
+    [PERSISTENCE_ACTIVE_FEATURE_FLAGS]?: string[];
+    [ENABLED_FEATURE_FLAGS]?: Record<string, string | boolean>;
+    [PERSISTENCE_FEATURE_FLAG_DETAILS]?: Record<string, FeatureFlagDetail>;
+    [PERSISTENCE_FEATURE_FLAG_PAYLOADS]?: Record<string, JsonType>;
+    [PERSISTENCE_FEATURE_FLAG_REQUEST_ID]?: string;
+    [PERSISTENCE_FEATURE_FLAG_EVALUATED_AT]?: number;
+    [PERSISTENCE_MINIMAL_FLAG_CALLED_EVENTS]?: boolean;
+    [PERSISTENCE_FEATURE_FLAG_ERRORS]?: string[];
+    [PERSISTENCE_OVERRIDE_FEATURE_FLAGS]?: Record<string, string | boolean>;
+    [PERSISTENCE_OVERRIDE_FEATURE_FLAG_PAYLOADS]?: Record<string, JsonType>;
+    [FLAG_CALL_REPORTED]?: Record<string, string[]>;
+    [FLAG_CALL_REPORTED_SESSION_ID]?: string;
+    [STORED_PERSON_PROPERTIES_KEY]?: Properties;
+    [STORED_GROUP_PROPERTIES_KEY]?: Record<string, Properties>;
+    [PERSISTENCE_EARLY_ACCESS_FEATURES]?: EarlyAccessFeature[];
+};
+/**
+ * Error type constants for the $feature_flag_error property.
+ *
+ * These values are sent in analytics events to track flag evaluation failures.
+ * They should not be changed without considering impact on existing dashboards
+ * and queries that filter on these values.
+ */
+export declare const FeatureFlagError: {
+    readonly ERRORS_WHILE_COMPUTING: 'errors_while_computing_flags';
+    readonly FLAG_MISSING: 'flag_missing';
+    readonly QUOTA_LIMITED: 'quota_limited';
+    readonly TIMEOUT: 'timeout';
+    readonly CONNECTION_ERROR: 'connection_error';
+    readonly UNKNOWN_ERROR: 'unknown_error';
+    readonly apiError: (status: number | string) => string;
+};
+export declare const filterActiveFeatureFlags: (featureFlags?: Record<string, string | boolean>) => Record<string, string | boolean>;
+export declare const parseFlagsResponse: (response: Partial<FlagsResponse>, currentFlags?: Record<string, string | boolean>, currentFlagPayloads?: Record<string, JsonType>, currentFlagDetails?: Record<string, FeatureFlagDetail>, options?: {
+    partialResponse?: boolean;
+}, responseLogger?: Logger) => FeatureFlagsState | undefined;
+export declare const QuotaLimitedResource: {
+    readonly FeatureFlags: 'feature_flags';
+    readonly Recordings: 'recordings';
+};
+export type QuotaLimitedResource = (typeof QuotaLimitedResource)[keyof typeof QuotaLimitedResource];
+export interface FeatureFlagsReloadResult {
+    /** loaded: evaluation completed; error: request/evaluation failed; skipped: evaluation unavailable; cancelled: reset/disposal. */
+    status: 'loaded' | 'error' | 'skipped' | 'cancelled';
+}
+export declare class PostHogFeatureFlags implements Extension {
+    readonly name: string;
+    _override_warning: boolean;
+    featureFlagEventHandlers: FeatureFlagsCallback[];
+    $anon_distinct_id: string | undefined;
+    private _window;
+    private _document;
+    private _client;
+    private _initializingClient;
+    private _logger;
+    private _dynamicProperties;
+    private _crossTabPersistenceUnsubscribe;
+    private _baseEventProperties;
+    private _eventPropertiesWithFlagValues;
+    private _bootstrapState;
+    private _reloadingHandlers;
+    private _pendingReloads;
+    private _activeReloads;
+    private _hasLoadedFlags;
+    private _requestInFlight;
+    private _requestGeneration;
+    private _reloadingDisabled;
+    private _additionalReloadRequested;
+    private _reloadDebouncer;
+    private _flagsLoadedFromRemote;
+    private _staleCacheRefreshTriggered;
+    private _consecutiveStatusZeroFailures;
+    private _refreshInterval;
+    private _refreshIntervalMs;
+    private _dueRefreshIntervalMs;
+    private _hadUserInteraction;
+    private _lastRefreshAt;
+    private readonly _configSource;
+    constructor(configSource: FeatureFlagsConfigSource);
+    /** Host persistence may merge flag snapshots across tabs independently of KV writes. */
+    protected get _crossTabPersistence(): {
+        onCrossTabFeatureFlagChange(handler: () => void): () => void;
+        markCrossTabFeatureFlagChanges(changes: Record<string, readonly string[] | true>): void;
+    } | undefined;
+    protected _onConfigUpdated(): void;
+    setup(client: Client): void | Promise<void>;
+    private _finishSetup;
+    private _onOnline;
+    private _refreshIfDue;
+    private _onUserInteraction;
+    private _onVisibilityChange;
+    private _resumeConfiguredInterval;
+    private _syncAutomaticRefresh;
+    private _scheduleNextRefresh;
+    private _stopAutomaticRefresh;
+    destroy(): void;
+    dispose(): void;
+    private _dispose;
+    private get _config();
+    private _prop;
+    private _clearBootstrapState;
+    private _fallBackToPersistedFlags;
+    private _set;
+    private _markCrossTabFeatureFlagSnapshot;
+    private _remove;
+    private _persist;
+    private _rebuildEventProperties;
+    /**
+     * Check if the feature flag cache is stale based on the configured TTL.
+     */
+    private _isCacheStale;
+    /**
+     * Triggers a debounced reload when cache staleness is first detected.
+     * Returns true if cache is stale, false otherwise.
+     */
+    private _checkAndTriggerStaleRefresh;
+    private _getValidEvaluationEnvironments;
+    private _getValidFlagKeys;
+    initialize(): void;
+    updateFlags(flags: Record<string, boolean | string>, payloads?: Record<string, JsonType>, options?: {
+        merge?: boolean;
+    }): void;
+    get hasLoadedFlags(): boolean;
+    getFlags(): string[];
+    getFlagsWithDetails(): Record<string, FeatureFlagDetail>;
+    getAllFeatureFlags(): FeatureFlagResult[];
+    getFlagVariants(): Record<string, string | boolean>;
+    getFlagPayloads(): Record<string, JsonType>;
+    /**
+     * Reloads feature flags asynchronously.
+     *
+     * Constraints:
+     *
+     * 1. Avoid parallel requests
+     * 2. Delay a few milliseconds after each reloadFeatureFlags call to batch subsequent changes together
+     */
+    reloadFeatureFlags(): void;
+    /** Await the next requested evaluation, rather than cached or locally injected flag changes. */
+    reloadFeatureFlagsAsync(): Promise<FeatureFlagsReloadResult>;
+    private _settleReloads;
+    private _clearDebouncer;
+    onReloading(handler: () => void): () => void;
+    ensureFlagsLoaded(): void;
+    setAnonymousDistinctId(anon_distinct_id: string | undefined): void;
+    setReloadingPaused(isPaused: boolean): void;
+    resetFlagCallReported(): void;
+    _callFlagsEndpoint(options?: {
+        disableFlags?: boolean;
+    }): void;
+    private _hasStatusZeroCircuitBreakerTripped;
+    private _trackStatusZeroReachability;
+    /**
+     * Get feature flag's value for user.
+     *
+     * By default, this method may return cached values from localStorage if the `/flags` endpoint
+     * hasn't responded yet. This reduces flicker but means you might briefly see stale values
+     * (e.g., a flag that was made globally inactive on the server).
+     *
+     * An evaluated boolean flag returns `true` or `false`; `undefined` means no current evaluation
+     * is available for the key. Globally inactive flags are omitted from the remote `/flags`
+     * response, so after that response loads they are unavailable rather than represented by
+     * a `false` result.
+     *
+     * ### Usage:
+     *
+     *     if(posthog.getFeatureFlag('my-flag') === 'some-variant') { // do something }
+     *
+     *     // Only use fresh values from the server (returns undefined until /flags responds)
+     *     if(posthog.getFeatureFlag('my-flag', { fresh: true }) === 'some-variant') { // do something }
+     *
+     * @param {String} key Key of the feature flag.
+     * @param {Object} options Optional settings.
+     * @param {boolean} [options.send_event=true] If false, won't send a $feature_flag_called event to PostHog.
+     * @param {boolean} [options.fresh=false] If true, only returns values loaded from the server, not cached localStorage values.
+     *                  Use this when you need to ensure the flag value reflects the current server state,
+     *                  such as after making a flag globally inactive. Returns undefined until the /flags endpoint responds.
+     * @returns {boolean | string | undefined} The flag value, or undefined if no current evaluation is available.
+     */
+    getFeatureFlag(key: string, options?: FeatureFlagOptions): boolean | string | undefined;
+    getFeatureFlagDetails(key: string): FeatureFlagDetail | undefined;
+    /**
+     * @deprecated Use `getFeatureFlagResult()` instead which properly tracks the feature flag call.
+     * `getFeatureFlagPayload()` does not emit the `$feature_flag_called` event which may result in
+     * missing analytics. This method will be removed in a future version.
+     */
+    getFeatureFlagPayload(key: string): JsonType;
+    /**
+     * Get a feature flag result including both the flag value and payload, while properly tracking the call.
+     * This method emits the `$feature_flag_called` event by default.
+     *
+     * By default, this method may return cached values from localStorage if the `/flags` endpoint
+     * hasn't responded yet. This reduces flicker but means you might briefly see stale values
+     * (e.g., a flag that was made globally inactive on the server).
+     *
+     * A result with `enabled: false` is a conclusive off evaluation. `undefined` means no current
+     * evaluation is available for the key. This includes globally inactive flags, which are omitted
+     * from the remote `/flags` response.
+     *
+     * ### Usage:
+     *
+     *     const result = posthog.getFeatureFlagResult('my-flag')
+     *     if (result?.enabled) {
+     *         console.log('Flag is enabled with payload:', result.payload)
+     *     }
+     *
+     *     // Only use fresh values from the server
+     *     const freshResult = posthog.getFeatureFlagResult('my-flag', { fresh: true })
+     *
+     * @param {String} key Key of the feature flag.
+     * @param {Object} [options] Options for the feature flag lookup.
+     * @param {boolean} [options.send_event=true] If false, won't send the $feature_flag_called event.
+     * @param {boolean} [options.fresh=false] If true, only returns values loaded from the server, not cached localStorage values.
+     *                  Use this when you need to ensure the flag value reflects the current server state.
+     *                  Returns undefined until the /flags endpoint responds.
+     * @returns {FeatureFlagResult | undefined} The feature flag result including key, enabled, variant, and payload.
+     */
+    getFeatureFlagResult(key: string, options?: FeatureFlagOptions): FeatureFlagResult | undefined;
+    private _captureFeatureFlagCalled;
+    getRemoteConfigPayload(key: string, callback: RemoteConfigFeatureFlagCallback): void;
+    private _getRemoteConfigPayload;
+    /**
+     * See if feature flag is enabled for user.
+     *
+     * By default, this method may return cached values from localStorage if the `/flags` endpoint
+     * hasn't responded yet. This reduces flicker but means you might briefly see stale values
+     * (e.g., a flag that was made globally inactive on the server).
+     *
+     * A `false` result means the flag value evaluated off; it does not mean the SDK observed the
+     * flag's global active setting. When no current evaluation is available, this method returns
+     * `options.defaultValue` if provided, otherwise `undefined`. Globally inactive flags are omitted
+     * from the remote `/flags` response and therefore have no value.
+     *
+     * ### Usage:
+     *
+     *     if(posthog.isFeatureEnabled('beta-feature')) { // do something }
+     *
+     *     // Only use fresh values from the server
+     *     if(posthog.isFeatureEnabled('beta-feature', { fresh: true })) { // do something }
+     *
+     * @param {String} key Key of the feature flag.
+     * @param {Object} [options] Optional settings.
+     * @param {boolean} [options.send_event=true] If false, won't send a $feature_flag_called event to PostHog.
+     * @param {boolean} [options.fresh=false] If true, only returns values loaded from the server, not cached localStorage values.
+     *                  Use this when you need to ensure the flag value reflects the current server state.
+     *                  Returns undefined until the /flags endpoint responds.
+     * @param {boolean} [options.defaultValue] Value to return when the flag has no value, e.g. flags have not loaded yet or no flag with that key exists.
+     * @returns {boolean | undefined} Whether the flag is enabled; when the flag has no value, defaultValue if given, otherwise undefined.
+     */
+    isFeatureEnabled(key: string, options: IsFeatureEnabledOptions & {
+        defaultValue: boolean;
+    }): boolean;
+    isFeatureEnabled(key: string, options?: IsFeatureEnabledOptions): boolean | undefined;
+    addFeatureFlagsHandler(handler: FeatureFlagsCallback): void;
+    removeFeatureFlagsHandler(handler: FeatureFlagsCallback): void;
+    receivedFeatureFlags(response: Partial<FlagsResponse>, errorsLoading?: boolean, options?: {
+        partialResponse?: boolean;
+    }): void;
+    private _receivedFeatureFlags;
+    /**
+     * @deprecated Use overrideFeatureFlags instead. This will be removed in a future version.
+     */
+    override(flags: boolean | string[] | Record<string, string | boolean>, suppressWarning?: boolean): void;
+    /**
+     * Override feature flags on the client-side. Useful for setting non-persistent feature flags,
+     * or for testing/debugging feature flags in the PostHog app.
+     *
+     * ### Usage:
+     *
+     *     - posthog.featureFlags.overrideFeatureFlags(false) // clear all overrides
+     *     - posthog.featureFlags.overrideFeatureFlags(['beta-feature']) // enable flags
+     *     - posthog.featureFlags.overrideFeatureFlags({'beta-feature': 'variant'}) // set variants
+     *     - posthog.featureFlags.overrideFeatureFlags({ flags: ['beta-feature'] }) // enable flags
+     *     - posthog.featureFlags.overrideFeatureFlags({ flags: {'beta-feature': 'variant'} }) // set variants
+     *     - posthog.featureFlags.overrideFeatureFlags({ // set both flags and payloads
+     *         flags: {'beta-feature': 'variant'},
+     *         payloads: { 'beta-feature': { someData: true } }
+     *       })
+     *     - posthog.featureFlags.overrideFeatureFlags({ // only override payloads
+     *         payloads: { 'beta-feature': { someData: true } }
+     *       })
+     */
+    overrideFeatureFlags(overrideOptions: OverrideFeatureFlagsOptions): void;
+    private _overrideFeatureFlags;
+    onFeatureFlags(callback: FeatureFlagsCallback): () => void;
+    updateEarlyAccessFeatureEnrollment(key: string, isEnrolled: boolean, stage?: string): void;
+    getEarlyAccessFeatures(callback: EarlyAccessFeatureCallback, force_reload?: boolean, stages?: EarlyAccessFeatureStage[]): void;
+    private _getEarlyAccessFeatures;
+    _prepareFeatureFlagsForCallbacks(): {
+        flags: string[];
+        flagVariants: Record<string, string | boolean>;
+    };
+    _fireFeatureFlagsCallbacks(errorsLoading?: boolean): void;
+    /**
+     * Set override person properties for feature flags.
+     * This is used when dealing with new persons / where you don't want to wait for ingestion
+     * to update user properties.
+     */
+    setPersonPropertiesForFlags(properties: Properties, reloadFeatureFlags?: boolean): void;
+    private _setPersonPropertiesForFlags;
+    /**
+     * Remove override person properties used for feature flags.
+     * This is the counterpart to setPersonPropertiesForFlags, used when person properties
+     * are unset so flags re-evaluate without the removed values.
+     */
+    unsetPersonPropertiesForFlags(propertyNames: string[], reloadFeatureFlags?: boolean): void;
+    resetPersonPropertiesForFlags(reloadFeatureFlags?: boolean): void;
+    /**
+     * Set override group properties for feature flags.
+     * This is used when dealing with new groups / where you don't want to wait for ingestion
+     * to update properties.
+     * Takes in an object, the key of which is the group type.
+     * For example:
+     *     setGroupPropertiesForFlags({'organization': { name: 'CYZ', employees: '11' } })
+     */
+    setGroupPropertiesForFlags(properties: {
+        [type: string]: Properties;
+    }, reloadFeatureFlags?: boolean): void;
+    resetGroupPropertiesForFlags(group_type?: string): void;
+    reset(): void;
+}
+export {};