posthog-react-native 3.14.0 → 3.15.0

package/lib/index.d.ts

@@ -0,0 +1,875 @@
+/// <reference types="react-native" />
+/// <reference types="react" />
+import PostHogReactNativeSessionReplay from 'posthog-react-native-session-replay';
+import { PostHogDecideResponse as PostHogDecideResponse$1 } from 'posthog-core';
+import { FeatureFlagValue as FeatureFlagValue$1, JsonType as JsonType$1 } from 'posthog-core/src';
+import React from 'react';
+import { StyleProp, ViewStyle } from 'react-native';
+
+type PostHogCoreOptions = {
+    /** PostHog API host, usually 'https://us.i.posthog.com' or 'https://eu.i.posthog.com' */
+    host?: string;
+    /** The number of events to queue before sending to PostHog (flushing) */
+    flushAt?: number;
+    /** The interval in milliseconds between periodic flushes */
+    flushInterval?: number;
+    /** The maximum number of queued messages to be flushed as part of a single batch (must be higher than `flushAt`) */
+    maxBatchSize?: number;
+    /** The maximum number of cached messages either in memory or on the local storage.
+     * Defaults to 1000, (must be higher than `flushAt`)
+     */
+    maxQueueSize?: number;
+    /** If set to true the SDK is essentially disabled (useful for local environments where you don't want to track anything) */
+    disabled?: boolean;
+    /** If set to false the SDK will not track until the `optIn` function is called. */
+    defaultOptIn?: boolean;
+    /** Whether to track that `getFeatureFlag` was called (used by Experiments) */
+    sendFeatureFlagEvent?: boolean;
+    /** Whether to load feature flags when initialized or not */
+    preloadFeatureFlags?: boolean;
+    /**
+     * Whether to load remote config when initialized or not
+     * Experimental support
+     * Default: false - Remote config is loaded by default
+     */
+    disableRemoteConfig?: boolean;
+    /**
+     * Whether to load surveys when initialized or not
+     * Experimental support
+     * Default: false - Surveys are loaded by default, but requires the `PostHogSurveyProvider` to be used
+     */
+    disableSurveys?: boolean;
+    /** Option to bootstrap the library with given distinctId and feature flags */
+    bootstrap?: {
+        distinctId?: string;
+        isIdentifiedId?: boolean;
+        featureFlags?: Record<string, FeatureFlagValue>;
+        featureFlagPayloads?: Record<string, JsonType>;
+    };
+    /** How many times we will retry HTTP requests. Defaults to 3. */
+    fetchRetryCount?: number;
+    /** The delay between HTTP request retries, Defaults to 3 seconds. */
+    fetchRetryDelay?: number;
+    /** Timeout in milliseconds for any calls. Defaults to 10 seconds. */
+    requestTimeout?: number;
+    /** Timeout in milliseconds for feature flag calls. Defaults to 10 seconds for stateful clients, and 3 seconds for stateless. */
+    featureFlagsRequestTimeoutMs?: number;
+    /** Timeout in milliseconds for remote config calls. Defaults to 3 seconds. */
+    remoteConfigRequestTimeoutMs?: number;
+    /** For Session Analysis how long before we expire a session (defaults to 30 mins) */
+    sessionExpirationTimeSeconds?: number;
+    /** Whether to post events to PostHog in JSON or compressed format. Defaults to 'json' */
+    captureMode?: 'json' | 'form';
+    disableGeoip?: boolean;
+    /** Special flag to indicate ingested data is for a historical migration. */
+    historicalMigration?: boolean;
+};
+declare enum PostHogPersistedProperty {
+    AnonymousId = "anonymous_id",
+    DistinctId = "distinct_id",
+    Props = "props",
+    FeatureFlagDetails = "feature_flag_details",
+    FeatureFlags = "feature_flags",
+    FeatureFlagPayloads = "feature_flag_payloads",
+    BootstrapFeatureFlagDetails = "bootstrap_feature_flag_details",
+    BootstrapFeatureFlags = "bootstrap_feature_flags",
+    BootstrapFeatureFlagPayloads = "bootstrap_feature_flag_payloads",
+    OverrideFeatureFlags = "override_feature_flags",
+    Queue = "queue",
+    OptedOut = "opted_out",
+    SessionId = "session_id",
+    SessionLastTimestamp = "session_timestamp",
+    PersonProperties = "person_properties",
+    GroupProperties = "group_properties",
+    InstalledAppBuild = "installed_app_build",
+    InstalledAppVersion = "installed_app_version",
+    SessionReplay = "session_replay",
+    DecideEndpointWasHit = "decide_endpoint_was_hit",
+    SurveyLastSeenDate = "survey_last_seen_date",
+    SurveysSeen = "surveys_seen",
+    Surveys = "surveys",
+    RemoteConfig = "remote_config"
+}
+type PostHogFetchOptions = {
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH';
+    mode?: 'no-cors';
+    credentials?: 'omit';
+    headers: {
+        [key: string]: string;
+    };
+    body?: string;
+    signal?: AbortSignal;
+};
+type PostHogCaptureOptions = {
+    /** If provided overrides the auto-generated event ID */
+    uuid?: string;
+    /** If provided overrides the auto-generated timestamp */
+    timestamp?: Date;
+    disableGeoip?: boolean;
+};
+type PostHogFetchResponse = {
+    status: number;
+    text: () => Promise<string>;
+    json: () => Promise<any>;
+};
+type PostHogEventProperties = {
+    [key: string]: any;
+};
+type PostHogAutocaptureElement = {
+    $el_text?: string;
+    tag_name: string;
+    href?: string;
+    nth_child?: number;
+    nth_of_type?: number;
+    order?: number;
+} & {
+    [key: string]: any;
+};
+type PostHogRemoteConfig = {
+    sessionRecording?: boolean | {
+        [key: string]: JsonType;
+    };
+    /**
+     * Whether surveys are enabled
+     */
+    surveys?: boolean | Survey[];
+    /**
+     * Indicates if the team has any flags enabled (if not we don't need to load them)
+     */
+    hasFeatureFlags?: boolean;
+};
+type FeatureFlagValue = string | boolean;
+type PostHogDecideResponse = Omit<PostHogRemoteConfig, 'surveys' | 'hasFeatureFlags'> & {
+    featureFlags: {
+        [key: string]: FeatureFlagValue;
+    };
+    featureFlagPayloads: {
+        [key: string]: JsonType;
+    };
+    flags: {
+        [key: string]: FeatureFlagDetail;
+    };
+    errorsWhileComputingFlags: boolean;
+    sessionRecording?: boolean | {
+        [key: string]: JsonType;
+    };
+    quotaLimited?: string[];
+    requestId?: string;
+};
+/**
+ * Creates a type with all properties of T, but makes only K properties required while the rest remain optional.
+ *
+ * @template T - The base type containing all properties
+ * @template K - Union type of keys from T that should be required
+ *
+ * @example
+ * interface User {
+ *   id: number;
+ *   name: string;
+ *   email?: string;
+ *   age?: number;
+ * }
+ *
+ * // Makes 'id' and 'name' required, but 'email' and 'age' optional
+ * type RequiredUser = PartialWithRequired<User, 'id' | 'name'>;
+ *
+ * const user: RequiredUser = {
+ *   id: 1,      // Must be provided
+ *   name: "John" // Must be provided
+ *   // email and age are optional
+ * };
+ */
+type PartialWithRequired<T, K extends keyof T> = {
+    [P in K]: T[P];
+} & {
+    [P in Exclude<keyof T, K>]?: T[P];
+};
+/**
+ * These are the fields we care about from PostHogDecideResponse for feature flags.
+ */
+type PostHogFeatureFlagDetails = PartialWithRequired<PostHogDecideResponse, 'flags' | 'featureFlags' | 'featureFlagPayloads' | 'requestId'>;
+type JsonType = string | number | boolean | null | {
+    [key: string]: JsonType;
+} | Array<JsonType>;
+type FeatureFlagDetail = {
+    key: string;
+    enabled: boolean;
+    variant: string | undefined;
+    reason: EvaluationReason | undefined;
+    metadata: FeatureFlagMetadata | undefined;
+};
+type FeatureFlagMetadata = {
+    id: number | undefined;
+    version: number | undefined;
+    description: string | undefined;
+    payload: string | undefined;
+};
+type EvaluationReason = {
+    code: string | undefined;
+    condition_index: number | undefined;
+    description: string | undefined;
+};
+type SurveyAppearance = {
+    backgroundColor?: string;
+    submitButtonColor?: string;
+    submitButtonText?: string;
+    submitButtonTextColor?: string;
+    ratingButtonColor?: string;
+    ratingButtonActiveColor?: string;
+    autoDisappear?: boolean;
+    displayThankYouMessage?: boolean;
+    thankYouMessageHeader?: string;
+    thankYouMessageDescription?: string;
+    thankYouMessageDescriptionContentType?: SurveyQuestionDescriptionContentType;
+    thankYouMessageCloseButtonText?: string;
+    borderColor?: string;
+    position?: SurveyPosition;
+    placeholder?: string;
+    shuffleQuestions?: boolean;
+    surveyPopupDelaySeconds?: number;
+    widgetType?: SurveyWidgetType;
+    widgetSelector?: string;
+    widgetLabel?: string;
+    widgetColor?: string;
+};
+declare enum SurveyPosition {
+    Left = "left",
+    Right = "right",
+    Center = "center"
+}
+declare enum SurveyWidgetType {
+    Button = "button",
+    Tab = "tab",
+    Selector = "selector"
+}
+declare enum SurveyType {
+    Popover = "popover",
+    API = "api",
+    Widget = "widget"
+}
+type SurveyQuestion = BasicSurveyQuestion | LinkSurveyQuestion | RatingSurveyQuestion | MultipleSurveyQuestion;
+declare enum SurveyQuestionDescriptionContentType {
+    Html = "html",
+    Text = "text"
+}
+type SurveyQuestionBase = {
+    question: string;
+    id?: string;
+    description?: string;
+    descriptionContentType?: SurveyQuestionDescriptionContentType;
+    optional?: boolean;
+    buttonText?: string;
+    originalQuestionIndex: number;
+    branching?: NextQuestionBranching | EndBranching | ResponseBasedBranching | SpecificQuestionBranching;
+};
+type BasicSurveyQuestion = SurveyQuestionBase & {
+    type: SurveyQuestionType.Open;
+};
+type LinkSurveyQuestion = SurveyQuestionBase & {
+    type: SurveyQuestionType.Link;
+    link?: string;
+};
+type RatingSurveyQuestion = SurveyQuestionBase & {
+    type: SurveyQuestionType.Rating;
+    display: SurveyRatingDisplay;
+    scale: 3 | 5 | 7 | 10;
+    lowerBoundLabel: string;
+    upperBoundLabel: string;
+};
+declare enum SurveyRatingDisplay {
+    Number = "number",
+    Emoji = "emoji"
+}
+type MultipleSurveyQuestion = SurveyQuestionBase & {
+    type: SurveyQuestionType.SingleChoice | SurveyQuestionType.MultipleChoice;
+    choices: string[];
+    hasOpenChoice?: boolean;
+    shuffleOptions?: boolean;
+};
+declare enum SurveyQuestionType {
+    Open = "open",
+    MultipleChoice = "multiple_choice",
+    SingleChoice = "single_choice",
+    Rating = "rating",
+    Link = "link"
+}
+declare enum SurveyQuestionBranchingType {
+    NextQuestion = "next_question",
+    End = "end",
+    ResponseBased = "response_based",
+    SpecificQuestion = "specific_question"
+}
+type NextQuestionBranching = {
+    type: SurveyQuestionBranchingType.NextQuestion;
+};
+type EndBranching = {
+    type: SurveyQuestionBranchingType.End;
+};
+type ResponseBasedBranching = {
+    type: SurveyQuestionBranchingType.ResponseBased;
+    responseValues: Record<string, any>;
+};
+type SpecificQuestionBranching = {
+    type: SurveyQuestionBranchingType.SpecificQuestion;
+    index: number;
+};
+type SurveyResponse = {
+    surveys: Survey[];
+};
+declare enum SurveyMatchType {
+    Regex = "regex",
+    NotRegex = "not_regex",
+    Exact = "exact",
+    IsNot = "is_not",
+    Icontains = "icontains",
+    NotIcontains = "not_icontains"
+}
+type Survey = {
+    id: string;
+    name: string;
+    description?: string;
+    type: SurveyType;
+    feature_flag_keys?: {
+        key: string;
+        value?: string;
+    }[];
+    linked_flag_key?: string;
+    targeting_flag_key?: string;
+    internal_targeting_flag_key?: string;
+    questions: SurveyQuestion[];
+    appearance?: SurveyAppearance;
+    conditions?: {
+        url?: string;
+        selector?: string;
+        seenSurveyWaitPeriodInDays?: number;
+        urlMatchType?: SurveyMatchType;
+        events?: {
+            repeatedActivation?: boolean;
+            values?: {
+                name: string;
+            }[];
+        };
+        actions?: {
+            values: SurveyActionType[];
+        };
+        deviceTypes?: string[];
+        deviceTypesMatchType?: SurveyMatchType;
+    };
+    start_date?: string;
+    end_date?: string;
+    current_iteration?: number;
+    current_iteration_start_date?: string;
+};
+type SurveyActionType = {
+    id: number;
+    name?: string;
+    steps?: ActionStepType[];
+};
+/** Sync with plugin-server/src/types.ts */
+declare enum ActionStepStringMatching {
+    Contains = "contains",
+    Exact = "exact",
+    Regex = "regex"
+}
+type ActionStepType = {
+    event?: string;
+    selector?: string;
+    /** @deprecated Only `selector` should be used now. */
+    tag_name?: string;
+    text?: string;
+    /** @default StringMatching.Exact */
+    text_matching?: ActionStepStringMatching;
+    href?: string;
+    /** @default ActionStepStringMatching.Exact */
+    href_matching?: ActionStepStringMatching;
+    url?: string;
+    /** @default StringMatching.Contains */
+    url_matching?: ActionStepStringMatching;
+};
+
+interface RetriableOptions {
+    retryCount: number;
+    retryDelay: number;
+    retryCheck: (err: any) => boolean;
+}
+
+declare class SimpleEventEmitter {
+    events: {
+        [key: string]: ((...args: any[]) => void)[];
+    };
+    constructor();
+    on(event: string, listener: (...args: any[]) => void): () => void;
+    emit(event: string, payload: any): void;
+}
+
+declare abstract class PostHogCoreStateless {
+    readonly apiKey: string;
+    readonly host: string;
+    readonly flushAt: number;
+    readonly preloadFeatureFlags: boolean;
+    readonly disableSurveys: boolean;
+    private maxBatchSize;
+    private maxQueueSize;
+    private flushInterval;
+    private flushPromise;
+    private requestTimeout;
+    private featureFlagsRequestTimeoutMs;
+    private remoteConfigRequestTimeoutMs;
+    private captureMode;
+    private removeDebugCallback?;
+    private disableGeoip;
+    private historicalMigration;
+    protected disabled: boolean;
+    private defaultOptIn;
+    private pendingPromises;
+    protected _events: SimpleEventEmitter;
+    protected _flushTimer?: any;
+    protected _retryOptions: RetriableOptions;
+    protected _initPromise: Promise<void>;
+    protected _isInitialized: boolean;
+    protected _remoteConfigResponsePromise?: Promise<PostHogRemoteConfig | undefined>;
+    abstract fetch(url: string, options: PostHogFetchOptions): Promise<PostHogFetchResponse>;
+    abstract getLibraryId(): string;
+    abstract getLibraryVersion(): string;
+    abstract getCustomUserAgent(): string | void;
+    abstract getPersistedProperty<T>(key: PostHogPersistedProperty): T | undefined;
+    abstract setPersistedProperty<T>(key: PostHogPersistedProperty, value: T | null): void;
+    constructor(apiKey: string, options?: PostHogCoreOptions);
+    protected logMsgIfDebug(fn: () => void): void;
+    protected wrap(fn: () => void): void;
+    protected getCommonEventProperties(): any;
+    get optedOut(): boolean;
+    optIn(): Promise<void>;
+    optOut(): Promise<void>;
+    on(event: string, cb: (...args: any[]) => void): () => void;
+    debug(enabled?: boolean): void;
+    get isDebug(): boolean;
+    get isDisabled(): boolean;
+    private buildPayload;
+    protected addPendingPromise<T>(promise: Promise<T>): Promise<T>;
+    /***
+     *** TRACKING
+     ***/
+    protected identifyStateless(distinctId: string, properties?: PostHogEventProperties, options?: PostHogCaptureOptions): void;
+    protected captureStateless(distinctId: string, event: string, properties?: {
+        [key: string]: any;
+    }, options?: PostHogCaptureOptions): void;
+    protected aliasStateless(alias: string, distinctId: string, properties?: {
+        [key: string]: any;
+    }, options?: PostHogCaptureOptions): void;
+    /***
+     *** GROUPS
+     ***/
+    protected groupIdentifyStateless(groupType: string, groupKey: string | number, groupProperties?: PostHogEventProperties, options?: PostHogCaptureOptions, distinctId?: string, eventProperties?: PostHogEventProperties): void;
+    protected getRemoteConfig(): Promise<PostHogRemoteConfig | undefined>;
+    /***
+     *** FEATURE FLAGS
+     ***/
+    protected getDecide(distinctId: string, groups?: Record<string, string | number>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>, extraPayload?: Record<string, any>): Promise<PostHogDecideResponse | undefined>;
+    protected getFeatureFlagStateless(key: string, distinctId: string, groups?: Record<string, string>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>, disableGeoip?: boolean): Promise<{
+        response: FeatureFlagValue | undefined;
+        requestId: string | undefined;
+    }>;
+    protected getFeatureFlagDetailStateless(key: string, distinctId: string, groups?: Record<string, string>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>, disableGeoip?: boolean): Promise<{
+        response: FeatureFlagDetail | undefined;
+        requestId: string | undefined;
+    } | undefined>;
+    protected getFeatureFlagPayloadStateless(key: string, distinctId: string, groups?: Record<string, string>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>, disableGeoip?: boolean): Promise<JsonType | undefined>;
+    protected getFeatureFlagPayloadsStateless(distinctId: string, groups?: Record<string, string>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>, disableGeoip?: boolean, flagKeysToEvaluate?: string[]): Promise<PostHogDecideResponse['featureFlagPayloads'] | undefined>;
+    protected getFeatureFlagsStateless(distinctId: string, groups?: Record<string, string | number>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>, disableGeoip?: boolean, flagKeysToEvaluate?: string[]): Promise<{
+        flags: PostHogDecideResponse['featureFlags'] | undefined;
+        payloads: PostHogDecideResponse['featureFlagPayloads'] | undefined;
+        requestId: PostHogDecideResponse['requestId'] | undefined;
+    }>;
+    protected getFeatureFlagsAndPayloadsStateless(distinctId: string, groups?: Record<string, string | number>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>, disableGeoip?: boolean, flagKeysToEvaluate?: string[]): Promise<{
+        flags: PostHogDecideResponse['featureFlags'] | undefined;
+        payloads: PostHogDecideResponse['featureFlagPayloads'] | undefined;
+        requestId: PostHogDecideResponse['requestId'] | undefined;
+    }>;
+    protected getFeatureFlagDetailsStateless(distinctId: string, groups?: Record<string, string | number>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>, disableGeoip?: boolean, flagKeysToEvaluate?: string[]): Promise<PostHogFeatureFlagDetails | undefined>;
+    /***
+     *** SURVEYS
+     ***/
+    getSurveysStateless(): Promise<SurveyResponse['surveys']>;
+    /***
+     *** QUEUEING AND FLUSHING
+     ***/
+    protected enqueue(type: string, _message: any, options?: PostHogCaptureOptions): void;
+    private clearFlushTimer;
+    /**
+     * Helper for flushing the queue in the background
+     * Avoids unnecessary promise errors
+     */
+    private flushBackground;
+    flush(): Promise<any[]>;
+    protected getCustomHeaders(): {
+        [key: string]: string;
+    };
+    private _flush;
+    private fetchWithRetry;
+    shutdown(shutdownTimeoutMs?: number): Promise<void>;
+}
+declare abstract class PostHogCore extends PostHogCoreStateless {
+    private sendFeatureFlagEvent;
+    private flagCallReported;
+    protected _decideResponsePromise?: Promise<PostHogDecideResponse | undefined>;
+    protected _sessionExpirationTimeSeconds: number;
+    protected sessionProps: PostHogEventProperties;
+    constructor(apiKey: string, options?: PostHogCoreOptions);
+    protected setupBootstrap(options?: Partial<PostHogCoreOptions>): void;
+    private get props();
+    private set props(value);
+    private clearProps;
+    private _props;
+    on(event: string, cb: (...args: any[]) => void): () => void;
+    reset(propertiesToKeep?: PostHogPersistedProperty[]): void;
+    protected getCommonEventProperties(): any;
+    private enrichProperties;
+    /**
+     * * @returns {string} The stored session ID for the current session. This may be an empty string if the client is not yet fully initialized.
+     */
+    getSessionId(): string;
+    resetSessionId(): void;
+    /**
+     * * @returns {string} The stored anonymous ID. This may be an empty string if the client is not yet fully initialized.
+     */
+    getAnonymousId(): string;
+    /**
+     * * @returns {string} The stored distinct ID. This may be an empty string if the client is not yet fully initialized.
+     */
+    getDistinctId(): string;
+    unregister(property: string): Promise<void>;
+    register(properties: {
+        [key: string]: any;
+    }): Promise<void>;
+    registerForSession(properties: {
+        [key: string]: any;
+    }): void;
+    unregisterForSession(property: string): void;
+    /***
+     *** TRACKING
+     ***/
+    identify(distinctId?: string, properties?: PostHogEventProperties, options?: PostHogCaptureOptions): void;
+    capture(event: string, properties?: {
+        [key: string]: any;
+    }, options?: PostHogCaptureOptions): void;
+    alias(alias: string): void;
+    autocapture(eventType: string, elements: PostHogAutocaptureElement[], properties?: PostHogEventProperties, options?: PostHogCaptureOptions): void;
+    /***
+     *** GROUPS
+     ***/
+    groups(groups: {
+        [type: string]: string | number;
+    }): void;
+    group(groupType: string, groupKey: string | number, groupProperties?: PostHogEventProperties, options?: PostHogCaptureOptions): void;
+    groupIdentify(groupType: string, groupKey: string | number, groupProperties?: PostHogEventProperties, options?: PostHogCaptureOptions): void;
+    /***
+     * PROPERTIES
+     ***/
+    setPersonPropertiesForFlags(properties: {
+        [type: string]: string;
+    }): void;
+    resetPersonPropertiesForFlags(): void;
+    /** @deprecated - Renamed to setPersonPropertiesForFlags */
+    personProperties(properties: {
+        [type: string]: string;
+    }): void;
+    setGroupPropertiesForFlags(properties: {
+        [type: string]: Record<string, string>;
+    }): void;
+    resetGroupPropertiesForFlags(): void;
+    /** @deprecated - Renamed to setGroupPropertiesForFlags */
+    groupProperties(properties: {
+        [type: string]: Record<string, string>;
+    }): void;
+    private remoteConfigAsync;
+    /***
+     *** FEATURE FLAGS
+     ***/
+    private decideAsync;
+    private cacheSessionReplay;
+    private _remoteConfigAsync;
+    private _decideAsync;
+    private setKnownFeatureFlagDetails;
+    private getKnownFeatureFlagDetails;
+    private getKnownFeatureFlags;
+    private getKnownFeatureFlagPayloads;
+    private getBootstrappedFeatureFlagDetails;
+    private setBootstrappedFeatureFlagDetails;
+    private getBootstrappedFeatureFlags;
+    private getBootstrappedFeatureFlagPayloads;
+    getFeatureFlag(key: string): FeatureFlagValue | undefined;
+    getFeatureFlagPayload(key: string): JsonType | undefined;
+    getFeatureFlagPayloads(): PostHogDecideResponse['featureFlagPayloads'] | undefined;
+    getFeatureFlags(): PostHogDecideResponse['featureFlags'] | undefined;
+    getFeatureFlagDetails(): PostHogFeatureFlagDetails | undefined;
+    getFeatureFlagsAndPayloads(): {
+        flags: PostHogDecideResponse['featureFlags'] | undefined;
+        payloads: PostHogDecideResponse['featureFlagPayloads'] | undefined;
+    };
+    isFeatureEnabled(key: string): boolean | undefined;
+    reloadFeatureFlags(cb?: (err?: Error, flags?: PostHogDecideResponse['featureFlags']) => void): void;
+    reloadRemoteConfigAsync(): Promise<PostHogRemoteConfig | undefined>;
+    reloadFeatureFlagsAsync(sendAnonDistinctId?: boolean): Promise<PostHogDecideResponse['featureFlags'] | undefined>;
+    onFeatureFlags(cb: (flags: PostHogDecideResponse['featureFlags']) => void): () => void;
+    onFeatureFlag(key: string, cb: (value: FeatureFlagValue) => void): () => void;
+    overrideFeatureFlag(flags: PostHogDecideResponse['featureFlags'] | null): Promise<void>;
+    /***
+     *** ERROR TRACKING
+     ***/
+    captureException(error: unknown, additionalProperties?: {
+        [key: string]: any;
+    }): void;
+    /**
+     * Capture written user feedback for a LLM trace. Numeric values are converted to strings.
+     * @param traceId The trace ID to capture feedback for.
+     * @param userFeedback The feedback to capture.
+     */
+    captureTraceFeedback(traceId: string | number, userFeedback: string): void;
+    /**
+     * Capture a metric for a LLM trace. Numeric values are converted to strings.
+     * @param traceId The trace ID to capture the metric for.
+     * @param metricName The name of the metric to capture.
+     * @param metricValue The value of the metric to capture.
+     */
+    captureTraceMetric(traceId: string | number, metricName: string, metricValue: string | number | boolean): void;
+}
+
+type PostHogAutocaptureNavigationTrackerOptions = {
+    routeToName?: (name: string, params: any) => string;
+    routeToProperties?: (name: string, params: any) => Record<string, any>;
+};
+type PostHogNavigationRef = {
+    getCurrentRoute(): any | undefined;
+    isReady: () => boolean;
+};
+type PostHogAutocaptureOptions = {
+    captureTouches?: boolean;
+    customLabelProp?: string;
+    noCaptureProp?: string;
+    maxElementsCaptured?: number;
+    ignoreLabels?: string[];
+    propsToCapture?: string[];
+    captureScreens?: boolean;
+    navigation?: PostHogAutocaptureNavigationTrackerOptions;
+    navigationRef?: PostHogNavigationRef;
+    /** Captures app lifecycle events such as Application Installed, Application Updated, Application Opened, Application Became Active and Application Backgrounded.
+     * By default is true.
+     * If you're already using the 'captureNativeAppLifecycleEvents' client option, you don't need to set this.
+     * If 'captureNativeAppLifecycleEvents' is set, the 'captureNativeAppLifecycleEvents' value has priority over this option.
+     * Application Installed and Application Updated events are not supported with persistence set to 'memory'.
+     */
+    captureLifecycleEvents?: boolean;
+};
+interface PostHogCustomAppProperties {
+    /** Build number like "1.2.2" or "122" */
+    $app_build?: string | null;
+    /** Name of the app as displayed below the icon like "PostHog" */
+    $app_name?: string | null;
+    /** Namespace of the app usually like "com.posthog.app" */
+    $app_namespace?: string | null;
+    /** Human friendly app version like what a user would see in the app store like "1.2.2" */
+    $app_version?: string | null;
+    /** Manufacturer like "Apple", "Samsung" or "Android" */
+    $device_manufacturer?: string | null;
+    /** Readable model name like "iPhone 12" or "Samsung Galaxy S24" */
+    $device_name?: string | null;
+    /** Model identifier like "iPhone13,2" or "SM-S921B" */
+    $device_model?: string | null;
+    /** Device type ("Mobile" | "Desktop" | "Web") */
+    $device_type?: string | null;
+    /** Operating system name like iOS or Android */
+    $os_name?: string | null;
+    /** Operating system version "14.0" */
+    $os_version?: string | null;
+    /** Locale (language) of the device like "en-US" */
+    $locale?: string | null;
+    /** Timezone of the device like "Europe/Berlin" */
+    $timezone?: string | null;
+}
+type PostHogSessionReplayConfig = {
+    /**
+     * Enable masking of all text and text input fields
+     * Default: true
+     */
+    maskAllTextInputs?: boolean;
+    /**
+     * Enable masking of all images to a placeholder
+     * Default: true
+     */
+    maskAllImages?: boolean;
+    /**
+     * Enable masking of all sandboxed system views
+     * These may include UIImagePickerController, PHPickerViewController and CNContactPickerViewController
+     * iOS only
+     * Experimental support
+     * Default: true
+     */
+    maskAllSandboxedViews?: boolean;
+    /**
+     * Enable masking of images that likely originated from user's photo library
+     * Experimental support (UIKit only)
+     * iOS only
+     * Default: false
+     *
+     * @deprecated This property has no effect and will be removed in the next major release. To learn how to manually mask user photos please see our Privacy controls documentation: https://posthog.com/docs/session-replay/privacy?tab=React+Native
+     */
+    maskPhotoLibraryImages?: boolean;
+    /**
+     * Enable capturing of logcat as console events
+     * Android only
+     * Default: true
+     */
+    captureLog?: boolean;
+    /**
+     * Deboucer delay used to reduce the number of snapshots captured and reduce performance impact
+     * This is used for capturing the view as a screenshot
+     * The lower the number more snapshots will be captured but higher the performance impact
+     * Defaults to 1s on iOS
+     */
+    iOSdebouncerDelayMs?: number;
+    /**
+     * Deboucer delay used to reduce the number of snapshots captured and reduce performance impact
+     * This is used for capturing the view as a screenshot
+     * The lower the number more snapshots will be captured but higher the performance impact
+     * Defaults to 1000ms (1s)
+     * Ps: it was 500ms (0.5s) by default until version 3.3.7
+     */
+    androidDebouncerDelayMs?: number;
+    /**
+     * Enable capturing network telemetry
+     * iOS only
+     * Default: true
+     */
+    captureNetworkTelemetry?: boolean;
+};
+interface PostHogCustomStorage {
+    getItem: (key: string) => string | null | Promise<string | null>;
+    setItem: (key: string, value: string) => void | Promise<void>;
+}
+
+declare let OptionalReactNativeSessionReplay: typeof PostHogReactNativeSessionReplay | undefined;
+
+type PostHogOptions = PostHogCoreOptions & {
+    /** Allows you to provide the storage type. By default 'file'.
+     * 'file' will try to load the best available storage, the provided 'customStorage', 'customAsyncStorage' or in-memory storage.
+     */
+    persistence?: 'memory' | 'file';
+    /** Allows you to provide your own implementation of the common information about your App or a function to modify the default App properties generated */
+    customAppProperties?: PostHogCustomAppProperties | ((properties: PostHogCustomAppProperties) => PostHogCustomAppProperties);
+    /** Allows you to provide a custom asynchronous storage such as async-storage, expo-file-system or a synchronous storage such as mmkv.
+     * If not provided, PostHog will attempt to use the best available storage via optional peer dependencies (async-storage, expo-file-system).
+     * If `persistence` is set to 'memory', this option will be ignored.
+     */
+    customStorage?: PostHogCustomStorage;
+    /** Captures app lifecycle events such as Application Installed, Application Updated, Application Opened, Application Became Active and Application Backgrounded.
+     * By default is false.
+     * If you're already using the 'captureLifecycleEvents' options with 'withReactNativeNavigation' or 'PostHogProvider, you don't need to set this.
+     * If this is set, this value has priority over the 'captureLifecycleEvents' option.
+     * Application Installed and Application Updated events are not supported with persistence set to 'memory'.
+     */
+    captureNativeAppLifecycleEvents?: boolean;
+    /**
+     * Enable Recording of Session Replays for Android and iOS
+     * Requires Record user sessions to be enabled in the PostHog Project Settings
+     * Defaults to false
+     */
+    enableSessionReplay?: boolean;
+    /**
+     * Configuration for Session Replay
+     */
+    sessionReplayConfig?: PostHogSessionReplayConfig;
+    /**
+     * If enabled, the session id ($session_id) will be persisted across app restarts.
+     * This is an option for back compatibility, so your current data isn't skewed with the new version of the SDK.
+     * If this is false, the session id will be always reset on app restart.
+     * Defaults to false
+     */
+    enablePersistSessionIdAcrossRestart?: boolean;
+};
+declare class PostHog extends PostHogCore {
+    private _persistence;
+    private _storage;
+    private _appProperties;
+    private _currentSessionId?;
+    private _enableSessionReplay?;
+    private _disableSurveys;
+    private _disableRemoteConfig;
+    constructor(apiKey: string, options?: PostHogOptions);
+    ready(): Promise<void>;
+    getPersistedProperty<T>(key: PostHogPersistedProperty): T | undefined;
+    setPersistedProperty<T>(key: PostHogPersistedProperty, value: T | null): void;
+    fetch(url: string, options: PostHogFetchOptions): Promise<PostHogFetchResponse>;
+    getLibraryId(): string;
+    getLibraryVersion(): string;
+    getCustomUserAgent(): string;
+    getCommonEventProperties(): any;
+    screen(name: string, properties?: {
+        [key: string]: any;
+    }, options?: PostHogCaptureOptions): Promise<void>;
+    _isEnableSessionReplay(): boolean;
+    _resetSessionId(reactNativeSessionReplay: typeof OptionalReactNativeSessionReplay | undefined, sessionId: string): void;
+    getSessionId(): string;
+    resetSessionId(): void;
+    identify(distinctId?: string, properties?: PostHogEventProperties, options?: PostHogCaptureOptions): void;
+    initReactNativeNavigation(options: PostHogAutocaptureOptions): boolean;
+    getSurveys(): Promise<SurveyResponse['surveys']>;
+    private startSessionReplay;
+    private captureNativeAppLifecycleEvents;
+    private persistAppVersion;
+}
+
+declare function _useNavigationTracker(options?: PostHogAutocaptureNavigationTrackerOptions, navigationRef?: PostHogNavigationRef, client?: PostHog): void;
+declare const useNavigationTracker: typeof _useNavigationTracker;
+
+declare function useFeatureFlags(client?: PostHog): PostHogDecideResponse$1['featureFlags'] | undefined;
+
+declare function useFeatureFlag(flag: string, client?: PostHog): FeatureFlagValue$1 | undefined;
+type FeatureFlagWithPayload = [FeatureFlagValue$1 | undefined, JsonType$1 | undefined];
+declare function useFeatureFlagWithPayload(flag: string, client?: PostHog): FeatureFlagWithPayload;
+
+declare const usePostHog: () => PostHog;
+
+interface PostHogProviderProps {
+    children: React.ReactNode;
+    options?: PostHogOptions;
+    apiKey?: string;
+    client?: PostHog;
+    autocapture?: boolean | PostHogAutocaptureOptions;
+    debug?: boolean;
+    style?: StyleProp<ViewStyle>;
+}
+declare const PostHogProvider: ({ children, client, options, apiKey, autocapture, style, debug, }: PostHogProviderProps) => JSX.Element | null;
+
+type PostHogSurveyProviderProps = {
+    /**
+     * The default appearance for surveys when not specified in PostHog.
+     */
+    defaultSurveyAppearance?: SurveyAppearance;
+    /**
+     * If true, PosHog appearance will be ignored and defaultSurveyAppearance is always used.
+     */
+    overrideAppearanceWithDefault?: boolean;
+    client?: PostHog;
+    children: React.ReactNode;
+};
+declare function PostHogSurveyProvider(props: PostHogSurveyProviderProps): JSX.Element;
+
+type SurveyAppearanceTheme = Omit<Required<SurveyAppearance>, 'widgetSelector' | 'widgetType' | 'widgetColor' | 'widgetLabel' | 'shuffleQuestions'>;
+
+type SurveyModalProps = {
+    survey: Survey;
+    appearance: SurveyAppearanceTheme;
+    onShow: () => void;
+    onClose: (submitted: boolean) => void;
+};
+declare function SurveyModal(props: SurveyModalProps): JSX.Element | null;
+
+declare function Questions({ survey, appearance, styleOverrides, onSubmit, }: {
+    survey: Survey;
+    appearance: SurveyAppearanceTheme;
+    styleOverrides?: StyleProp<ViewStyle>;
+    onSubmit: () => void;
+}): JSX.Element;
+
+export { FeatureFlagWithPayload, PostHog, PostHogAutocaptureNavigationTrackerOptions, PostHogAutocaptureOptions, PostHogCustomAppProperties, PostHogCustomStorage, PostHogNavigationRef, PostHogOptions, PostHogProvider, PostHogProviderProps, PostHogSessionReplayConfig, PostHogSurveyProvider, PostHogSurveyProviderProps, Questions, Survey, SurveyAppearance, SurveyModal, SurveyModalProps, PostHog as default, useFeatureFlag, useFeatureFlagWithPayload, useFeatureFlags, useNavigationTracker, usePostHog };