@rudderstack/analytics-js 3.0.0-beta.6 → 3.0.0-beta.8

package/dist/npm/index.d.ts

@@ -0,0 +1,1229 @@
+/// <reference types="../node_modules/user-agent-data-types/index.d.ts" />
+import { Signal } from '@preact/signals-core';
+
+type LoggerProvider$1 = Record<Exclude<Lowercase<LogLevel>, Lowercase<LogLevel.None>>, (...data: any[]) => void>;
+interface ILogger {
+    minLogLevel: number;
+    scope?: string;
+    logProvider: LoggerProvider$1;
+    log(...data: any[]): void;
+    info(...data: any[]): void;
+    debug(...data: any[]): void;
+    warn(...data: any[]): void;
+    error(...data: any[]): void;
+    setScope(scopeVal: string): void;
+    setMinLogLevel(logLevel: LogLevel): void;
+}
+declare enum LogLevel {
+    Log = "LOG",
+    Info = "INFO",
+    Debug = "DEBUG",
+    Warn = "WARN",
+    Error = "ERROR",
+    None = "NONE"
+}
+
+type RegionDetails = {
+    url: string;
+    default: boolean;
+};
+/**
+ * Represents residency server input the options
+ */
+declare enum ResidencyServerRegion {
+    US = "US",
+    EU = "EU"
+}
+
+type Nullable<T> = T | null;
+
+interface ExtensionPoint {
+    [lifeCycleName: string]: (...args: any[]) => unknown;
+}
+/**
+ * ExtensionPoint can be nested, e.g. 'sdk.initialize.phase1'
+ * When index signature is provided, every key have to match the type, the types
+ * for 'name', 'deps',  and 'initialize' is added as index signature.
+ */
+interface ExtensionPlugin {
+    name: string;
+    initialize?: (state?: any) => void;
+    deps?: string[];
+    [key: string]: string | (() => void) | ExtensionPoint | ((...args: any[]) => unknown | void) | string[] | undefined;
+}
+type PluginEngineConfig = {
+    throws?: boolean | RegExp;
+};
+interface IPluginEngine {
+    plugins: ExtensionPlugin[];
+    byName: Record<string, ExtensionPlugin>;
+    cache: Record<string, ExtensionPlugin[]>;
+    config: PluginEngineConfig;
+    register: (plugin: ExtensionPlugin, state?: Record<string, any>) => void;
+    unregister: (name: string) => void;
+    getPlugin: (name: string) => ExtensionPlugin | undefined;
+    getPlugins: (extPoint?: string) => ExtensionPlugin[];
+    invoke: <T = any>(extPoint?: string, allowMultiple?: boolean, ...args: any[]) => Nullable<T>[];
+    invokeSingle: <T = any>(extPoint?: string, ...args: any[]) => Nullable<T>;
+    invokeMultiple: <T = any>(extPoint?: string, ...args: any[]) => Nullable<T>[];
+}
+
+interface IPluginsManager {
+    engine: IPluginEngine;
+    init(): void;
+    attachEffects(): void;
+    setActivePlugins(): void;
+    invokeMultiple<T = any>(extPoint?: string, ...args: any[]): Nullable<T>[];
+    invokeSingle<T = any>(extPoint?: string, ...args: any[]): Nullable<T>;
+    register(plugins: ExtensionPlugin[]): void;
+}
+declare enum PluginName {
+    BeaconQueue = "BeaconQueue",
+    Bugsnag = "Bugsnag",
+    DeviceModeDestinations = "DeviceModeDestinations",
+    DeviceModeTransformation = "DeviceModeTransformation",
+    ErrorReporting = "ErrorReporting",
+    ExternalAnonymousId = "ExternalAnonymousId",
+    GoogleLinker = "GoogleLinker",
+    KetchConsentManager = "KetchConsentManager",
+    NativeDestinationQueue = "NativeDestinationQueue",
+    OneTrustConsentManager = "OneTrustConsentManager",
+    StorageEncryption = "StorageEncryption",
+    StorageEncryptionLegacy = "StorageEncryptionLegacy",
+    StorageMigrator = "StorageMigrator",
+    XhrQueue = "XhrQueue"
+}
+
+/**
+ * Represents a generic object in the APIs
+ * Use for parameters like properties, traits etc.
+ */
+type ApiObject = {
+    [index: string]: string | number | boolean | ApiObject | null | (string | number | boolean | null | ApiObject)[] | undefined;
+};
+
+type DestinationIntgConfig = boolean | undefined | ApiObject;
+/**
+ * Represents the integration options object
+ * Example usages:
+ * integrationOptions { All: false, "Google Analytics": true, "Braze": true}
+ * integrationOptions { All: true, "Chartbeat": false, "Customer.io": false}
+ * integrationOptions { All: true, "GA4": { "clientId": "1234" }, "Google Analytics": false }
+ */
+type IntegrationOpts = {
+    All?: boolean;
+    [index: string]: DestinationIntgConfig;
+};
+
+type Traits = Nullable<ApiObject>;
+type ApiCallback = (data?: any) => void;
+/**
+ * Represents the options parameter in the APIs
+ */
+type ApiOptions = {
+    integrations?: IntegrationOpts;
+    anonymousId?: string;
+    originalTimestamp?: string;
+    [index: string]: string | number | boolean | ApiObject | null | (string | number | boolean | ApiObject)[] | undefined;
+};
+type APIEvent = {
+    type: RudderEventType;
+    category?: string;
+    name?: string;
+    properties?: Nullable<ApiObject>;
+    options?: Nullable<ApiOptions>;
+    callback?: () => void;
+    userId?: Nullable<string>;
+    traits?: Nullable<ApiObject>;
+    to?: Nullable<string>;
+    from?: string;
+    groupId?: Nullable<string>;
+};
+declare enum RudderEventType {
+    Page = "page",
+    Track = "track",
+    Identify = "identify",
+    Alias = "alias",
+    Group = "group"
+}
+type ReadyCallback = () => void;
+
+type OneTrustCookieCategory = {
+    oneTrustCookieCategory: string;
+};
+type CookieConsentOptions = {
+    [key: string]: {
+        enabled: boolean;
+    };
+};
+type ConsentInfo = {
+    initialized: boolean;
+    allowedConsents?: Record<string, string> | string[];
+    deniedConsentIds?: string[];
+};
+type KetchConsentPurpose = {
+    purpose: string;
+};
+
+declare enum UserSessionKeys {
+    userId = "userId",
+    userTraits = "userTraits",
+    anonymousId = "anonymousId",
+    groupId = "groupId",
+    groupTraits = "groupTraits",
+    initialReferrer = "initialReferrer",
+    initialReferringDomain = "initialReferringDomain",
+    sessionInfo = "sessionInfo"
+}
+
+declare enum StorageEncryptionVersion {
+    Legacy = "legacy",
+    V3 = "v3"
+}
+type StorageType = 'cookieStorage' | 'localStorage' | 'memoryStorage' | 'sessionStorage' | 'none';
+type StorageEncryption = {
+    version: StorageEncryptionVersion;
+};
+type LoadOptionStorageEntry = {
+    type: StorageType;
+};
+type StorageOpts = {
+    encryption?: StorageEncryption;
+    migrate?: boolean;
+    type?: StorageType;
+    cookie?: CookieOptions;
+    entries?: {
+        [key in UserSessionKeys]?: LoadOptionStorageEntry;
+    };
+};
+type CookieOptions = {
+    maxage?: number;
+    expires?: Date;
+    path?: string;
+    domain?: string;
+    samesite?: string;
+    secure?: boolean;
+};
+declare enum CookieSameSite {
+    Strict = "Strict",
+    Lax = "Lax",
+    None = "None"
+}
+
+declare enum UaChTrackLevel {
+    None = "none",
+    Default = "default",
+    Full = "full"
+}
+/**
+ * Represents the options parameter for anonymousId
+ */
+type AnonymousIdOptions = {
+    autoCapture?: {
+        enabled?: boolean;
+        source?: string;
+    };
+};
+type SessionOpts = {
+    autoTrack?: boolean;
+    timeout?: number;
+};
+type EventMapping = {
+    from: string;
+    to: string;
+};
+type Conversion = {
+    conversionLabel: string;
+    name: string;
+};
+type EventFilteringOption = 'disable' | 'whitelistedEvents' | 'blacklistedEvents';
+/**
+ * Represents the beacon queue options parameter in loadOptions type
+ */
+type BeaconQueueOpts = {
+    maxItems?: number;
+    flushQueueInterval?: number;
+};
+/**
+ * Represents the queue options parameter in loadOptions type
+ */
+type QueueOpts = {
+    maxRetryDelay?: number;
+    minRetryDelay?: number;
+    backoffFactor?: number;
+    maxAttempts?: number;
+    maxItems?: number;
+};
+/**
+ * Represents the destinations queue options parameter in loadOptions type
+ */
+type DestinationsQueueOpts = {
+    maxItems?: number;
+};
+type OnLoadedCallback = (analytics: any) => void;
+declare enum DeliveryType {
+    Immediate = "immediate",
+    Buffer = "buffer"
+}
+declare enum StorageStrategy {
+    None = "none",
+    Session = "session",
+    AnonymousId = "anonymousId"
+}
+type PreConsentStorageOptions = {
+    strategy: StorageStrategy;
+};
+type PreConsentEventsOptions = {
+    delivery: DeliveryType;
+};
+type PreConsentOptions = {
+    enabled: boolean;
+    storage?: PreConsentStorageOptions;
+    events?: PreConsentEventsOptions;
+    trackConsent?: boolean;
+};
+/**
+ * Represents the options parameter in the load API
+ */
+type LoadOptions = {
+    logLevel?: LogLevel;
+    integrations?: IntegrationOpts;
+    configUrl: string;
+    queueOptions?: QueueOpts;
+    loadIntegration?: boolean;
+    sessions: SessionOpts;
+    secureCookie?: boolean;
+    destSDKBaseURL?: string;
+    pluginsSDKBaseURL?: string;
+    useBeacon?: boolean;
+    beaconQueueOptions?: BeaconQueueOpts;
+    destinationsQueueOptions?: DestinationsQueueOpts;
+    cookieConsentManager?: CookieConsentOptions;
+    anonymousIdOptions?: AnonymousIdOptions;
+    setCookieDomain?: string;
+    sameSiteCookie: CookieSameSite;
+    lockIntegrationsVersion?: boolean;
+    polyfillIfRequired: boolean;
+    onLoaded?: OnLoadedCallback;
+    uaChTrackLevel?: UaChTrackLevel;
+    residencyServer?: ResidencyServerRegion;
+    getSourceConfig?: () => string | ApiObject | Promise<ApiObject> | Promise<string>;
+    sendAdblockPage?: boolean;
+    sendAdblockPageOptions?: ApiOptions;
+    plugins?: Nullable<PluginName[]>;
+    polyfillURL?: string;
+    useGlobalIntegrationsConfigInEvents?: boolean;
+    bufferDataPlaneEventsUntilReady?: boolean;
+    dataPlaneEventsBufferTimeout?: number;
+    storage?: StorageOpts;
+    preConsent?: PreConsentOptions;
+};
+
+type LoggerProvider = Record<Exclude<Lowercase<LogLevel>, Lowercase<LogLevel.None>>, (...data: any[]) => void>;
+
+/**
+ * Service to log messages/data to output provider, default is console
+ */
+declare class Logger implements ILogger {
+    minLogLevel: number;
+    scope?: string;
+    logProvider: LoggerProvider;
+    constructor(minLogLevel?: LogLevel, scope?: string, logProvider?: Console);
+    log(...data: any[]): void;
+    info(...data: any[]): void;
+    debug(...data: any[]): void;
+    warn(...data: any[]): void;
+    error(...data: any[]): void;
+    outputLog(logMethod: LogLevel, data: any[]): void;
+    setScope(scopeVal: string): void;
+    setMinLogLevel(logLevel: LogLevel): void;
+    /**
+     * Formats the console message using `scope` and styles
+     */
+    formatLogData(data: any[]): any[];
+}//# sourceMappingURL=Logger.d.ts.map
+
+type AnalyticsIdentifyMethod = {
+    (userId?: string, traits?: Nullable<ApiObject>, options?: Nullable<ApiOptions>, callback?: ApiCallback): void;
+    (userId: string, traits: Nullable<ApiObject>, callback: ApiCallback): void;
+    (userId: string, callback: ApiCallback): void;
+    (traits: Nullable<ApiObject>, options: Nullable<ApiOptions>, callback?: ApiCallback): void;
+    (traits: Nullable<ApiObject>, callback?: ApiCallback): void;
+};
+type AnalyticsPageMethod = {
+    (category?: string, name?: string, properties?: Nullable<ApiObject>, options?: Nullable<ApiOptions>, callback?: ApiCallback): void;
+    (category: string, name: string, properties: Nullable<ApiObject>, callback: ApiCallback): void;
+    (name: string, properties?: Nullable<ApiObject>, options?: Nullable<ApiOptions>, callback?: ApiCallback): void;
+    (category: string, name: string, callback: ApiCallback): void;
+    (name: string, properties: Nullable<ApiObject>, callback: ApiCallback): void;
+    (name: string, callback: ApiCallback): void;
+    (properties: Nullable<ApiObject>, options: Nullable<ApiOptions>, callback?: ApiCallback): void;
+    (properties: Nullable<ApiObject>, callback?: ApiCallback): void;
+};
+type AnalyticsTrackMethod = {
+    (event: string, properties?: Nullable<ApiObject>, options?: Nullable<ApiOptions>, callback?: ApiCallback): void;
+    (event: string, properties: Nullable<ApiObject>, callback: ApiCallback): void;
+    (event: string, callback: ApiCallback): void;
+};
+type AnalyticsGroupMethod = {
+    (groupId: string | number, traits?: Nullable<ApiObject>, options?: Nullable<ApiOptions>, callback?: ApiCallback): void;
+    (groupId: string | number, traits: Nullable<ApiObject>, callback: ApiCallback): void;
+    (groupId: string | number, callback: ApiCallback): void;
+    (traits: Nullable<ApiObject>, options: Nullable<ApiOptions>, callback?: ApiCallback): void;
+    (traits: Nullable<ApiObject>, callback?: ApiCallback): void;
+};
+type AnalyticsAliasMethod = {
+    (to: Nullable<string>, from?: string, options?: Nullable<ApiOptions>, callback?: ApiCallback): void;
+    (to: Nullable<string>, from: string, callback: ApiCallback): void;
+    (to: Nullable<string>, options: Nullable<ApiOptions>, callback?: ApiCallback): void;
+    (to: Nullable<string>, callback: ApiCallback): void;
+    (to: ApiCallback): void;
+    (): void;
+};
+interface IRudderAnalytics<T = any> {
+    analyticsInstances: Record<string, T>;
+    defaultAnalyticsKey: string;
+    logger: ILogger;
+    /**
+     * Set the writeKey of the analytics instance that should be default
+     */
+    setDefaultInstanceKey(writeKey: string, autoSet: boolean): void;
+    /**
+     * Get the instance of Analytics that is set as default
+     */
+    getAnalyticsInstance(writeKey?: string): T;
+    /**
+     * Trigger load event in buffer queue if exists
+     */
+    triggerBufferedLoadEvent(): void;
+    /**
+     * Call control pane to get client configs
+     */
+    load(writeKey: string, dataPlaneUrl: string, loadOptions?: Partial<LoadOptions>): void;
+    /**
+     * To register a callback for SDK ready state
+     */
+    ready(callback: ApiCallback): void;
+    /**
+     * To record a page view event
+     */
+    page: AnalyticsPageMethod;
+    /**
+     * To record a user track event
+     */
+    track: AnalyticsTrackMethod;
+    /**
+     * To record a user identification event
+     */
+    identify: AnalyticsIdentifyMethod;
+    /**
+     * To record a user alias event
+     */
+    alias: AnalyticsAliasMethod;
+    /**
+     * To record a user group event
+     */
+    group: AnalyticsGroupMethod;
+    /**
+     * Clear user information
+     *
+     * @param resetAnonymousId optionally clears anonymousId as well
+     */
+    reset(resetAnonymousId?: boolean): void;
+    /**
+     * To get anonymousId set in the SDK
+     *
+     * @param options options for anonymousId
+     */
+    getAnonymousId(options?: AnonymousIdOptions): string | undefined;
+    /**
+     * To set anonymousId
+     *
+     * @param anonymousId custom anonymousId value
+     * @param rudderAmpLinkerParam AMP Linker ID string
+     */
+    setAnonymousId(anonymousId?: string, rudderAmpLinkerParam?: string): void;
+    /**
+     * To get userId set in the SDK
+     */
+    getUserId(): Nullable<string> | undefined;
+    /**
+     * To get user traits set in the SDK
+     */
+    getUserTraits(): Nullable<ApiObject> | undefined;
+    /**
+     * To get groupId set in the SDK
+     */
+    getGroupId(): Nullable<string> | undefined;
+    /**
+     * To get group traits set in the SDK
+     */
+    getGroupTraits(): Nullable<ApiObject> | undefined;
+    /**
+     * To manually start user session in the SDK
+     */
+    startSession(sessionId?: number): void;
+    /**
+     * To manually end user session in the SDK
+     */
+    endSession(): void;
+    /**
+     * To fetch the current sessionId
+     */
+    getSessionId(): Nullable<number>;
+}
+
+interface IExternalSourceLoadConfig {
+    url: string;
+    id: string;
+    callback?(id?: string): unknown;
+    async?: boolean;
+    timeout?: number;
+    extraAttributes?: Record<string, string>;
+}
+interface IExternalSrcLoader {
+    errorHandler?: {
+        onError(error: unknown, context?: string, customMessage?: string, shouldAlwaysThrow?: boolean): void;
+        leaveBreadcrumb(breadcrumb: string): void;
+        notifyError(error: Error): void;
+    };
+    logger?: ILogger;
+    timeout: number;
+    loadJSFile(config: IExternalSourceLoadConfig): void;
+}
+
+type SDKError = unknown;
+interface IErrorHandler {
+    logger?: ILogger;
+    pluginEngine?: IPluginEngine;
+    init(externalSrcLoader: IExternalSrcLoader): void;
+    onError(error: SDKError, context?: string, customMessage?: string, shouldAlwaysThrow?: boolean): void;
+    leaveBreadcrumb(breadcrumb: string): void;
+    notifyError(error: Error): void;
+}
+
+interface IRequestConfig {
+    url: string;
+    options?: Partial<IXHRRequestOptions>;
+    isRawResponse?: boolean;
+    timeout?: number;
+}
+type ResponseDetails = {
+    response: string;
+    error?: Error;
+    xhr?: XMLHttpRequest;
+    options: IXHRRequestOptions;
+};
+interface IAsyncRequestConfig<T> extends IRequestConfig {
+    callback?(data?: T | string | undefined, details?: ResponseDetails): void;
+}
+interface IXHRRequestOptions {
+    method: HTTPClientMethod;
+    url: string;
+    headers: Record<string, string | undefined>;
+    data?: XMLHttpRequestBodyInit;
+    sendRawData?: boolean;
+}
+type HTTPClientMethod = 'get' | 'GET' | 'delete' | 'DELETE' | 'head' | 'HEAD' | 'options' | 'OPTIONS' | 'post' | 'POST' | 'put' | 'PUT' | 'patch' | 'PATCH' | 'purge' | 'PURGE' | 'link' | 'LINK' | 'unlink' | 'UNLINK';
+interface IHttpClient {
+    errorHandler?: IErrorHandler;
+    logger?: ILogger;
+    basicAuthHeader?: string;
+    hasErrorHandler: boolean;
+    getData<T = any>(config: IRequestConfig): Promise<{
+        data: T | string | undefined;
+        details?: ResponseDetails;
+    }>;
+    getAsyncData<T = any>(config: IAsyncRequestConfig<T>): void;
+    setAuthHeader(value: string, noBto?: boolean): void;
+    resetAuthHeader(): void;
+}
+
+declare enum LifecycleStatus {
+    Mounted = "mounted",
+    BrowserCapabilitiesReady = "browserCapabilitiesReady",
+    Configured = "configured",
+    PluginsLoading = "pluginsLoading",
+    PluginsReady = "pluginsReady",
+    Initialized = "initialized",
+    Loaded = "loaded",
+    DestinationsLoading = "destinationsLoading",
+    DestinationsReady = "destinationsReady",
+    Ready = "ready"
+}
+
+type StoreId = string;
+interface IStoreConfig {
+    name: string;
+    id: StoreId;
+    isEncrypted?: boolean;
+    validKeys?: Record<string, string>;
+    noCompoundKey?: boolean;
+    errorHandler?: IErrorHandler;
+    logger?: ILogger;
+    type?: StorageType;
+}
+interface IStoreManager {
+    stores?: Record<StoreId, IStore>;
+    isInitialized?: boolean;
+    errorHandler?: IErrorHandler;
+    logger?: ILogger;
+    init(): void;
+    initClientDataStore(): void;
+    setStore(storeConfig: IStoreConfig): IStore;
+    getStore(id: StoreId): IStore | undefined;
+}
+interface IStore {
+    id: string;
+    name: string;
+    isEncrypted: boolean;
+    validKeys: Record<string, string>;
+    engine: IStorage;
+    originalEngine: IStorage;
+    noKeyValidation?: boolean;
+    noCompoundKey?: boolean;
+    errorHandler?: IErrorHandler;
+    logger?: ILogger;
+    pluginsManager?: IPluginsManager;
+    createValidKey(key: string): string | undefined;
+    swapQueueStoreToInMemoryEngine(): void;
+    set(key: string, value: any): void;
+    get<T = any>(key: string): Nullable<T>;
+    remove(key: string): void;
+    getOriginalEngine(): IStorage;
+    decrypt(value?: Nullable<string>): Nullable<string>;
+    encrypt(value: any): string;
+    crypto(value: string, mode: 'encrypt' | 'decrypt'): string;
+    onError(error: unknown): void;
+}
+interface IStorage extends Storage {
+    configure?(options: StorageOptions): void;
+    isEnabled?: boolean;
+}
+type StorageOptions = Partial<ICookieStorageOptions | ILocalStorageOptions | IInMemoryStorageOptions>;
+interface ICookieStorageOptions extends CookieOptions {
+    samesite?: CookieSameSite;
+    domain?: string;
+    secure?: boolean;
+    enabled?: boolean;
+}
+interface ILocalStorageOptions {
+    enabled?: boolean;
+}
+interface IInMemoryStorageOptions {
+    enabled?: boolean;
+}
+
+type PageCallOptions = {
+    category?: string;
+    name?: string;
+    properties?: Nullable<ApiObject>;
+    options?: Nullable<ApiOptions>;
+    callback?: ApiCallback;
+};
+type TrackCallOptions = {
+    name: string;
+    properties?: Nullable<ApiObject>;
+    options?: Nullable<ApiOptions>;
+    callback?: ApiCallback;
+};
+type IdentifyCallOptions = {
+    userId?: string | null;
+    traits?: Nullable<ApiObject>;
+    options?: Nullable<ApiOptions>;
+    callback?: ApiCallback;
+};
+type AliasCallOptions = {
+    to?: Nullable<string>;
+    from?: Nullable<string>;
+    options?: Nullable<ApiOptions>;
+    callback?: ApiCallback;
+};
+type GroupCallOptions = {
+    groupId?: Nullable<string>;
+    traits?: Nullable<ApiObject>;
+    options?: Nullable<ApiOptions>;
+    callback?: ApiCallback;
+};
+
+/**
+ * Store Implementation with dedicated storage
+ */
+declare class Store implements IStore {
+    id: string;
+    name: string;
+    isEncrypted: boolean;
+    validKeys: Record<string, string>;
+    engine: IStorage;
+    originalEngine: IStorage;
+    noKeyValidation?: boolean;
+    noCompoundKey?: boolean;
+    errorHandler?: IErrorHandler;
+    hasErrorHandler: boolean;
+    logger?: ILogger;
+    pluginsManager?: IPluginsManager;
+    constructor(config: IStoreConfig, engine?: IStorage, pluginsManager?: IPluginsManager);
+    /**
+     * Ensure the key is valid and with correct format
+     */
+    createValidKey(key: string): string | undefined;
+    /**
+     * Switch to inMemoryEngine, bringing any existing data with.
+     */
+    swapQueueStoreToInMemoryEngine(): void;
+    /**
+     * Set value by key.
+     */
+    set(key: string, value: any): void;
+    /**
+     * Get by Key.
+     */
+    get<T = any>(key: string): Nullable<T>;
+    /**
+     * Remove by Key.
+     */
+    remove(key: string): void;
+    /**
+     * Get original engine
+     */
+    getOriginalEngine(): IStorage;
+    /**
+     * Decrypt values
+     */
+    decrypt(value?: Nullable<string>): Nullable<string>;
+    /**
+     * Encrypt value
+     */
+    encrypt(value: Nullable<any>): string;
+    /**
+     * Extension point to use with encryption plugins
+     */
+    crypto(value: Nullable<any>, mode: 'encrypt' | 'decrypt'): string;
+    /**
+     * Handle errors
+     */
+    onError(error: unknown): void;
+}
+//# sourceMappingURL=Store.d.ts.map
+
+interface IUserSessionManager {
+    storeManager?: IStoreManager;
+    init(): void;
+    setAnonymousId(anonymousId?: string, rudderAmpLinkerParam?: string): void;
+    getAnonymousId(options?: AnonymousIdOptions): string;
+    refreshSession(): void;
+    getSessionId(): Nullable<number>;
+    getGroupId(): Nullable<string>;
+    getUserId(): Nullable<string>;
+    setUserId(userId?: null | string): void;
+    setUserTraits(traits?: Nullable<ApiObject>): void;
+    getUserTraits(): Nullable<ApiObject>;
+    getGroupTraits(): Nullable<ApiObject>;
+    setGroupId(groupId?: Nullable<string>): void;
+    setGroupTraits(traits?: Nullable<ApiObject>): void;
+    reset(resetAnonymousId?: boolean, noNewSessionStart?: boolean): void;
+    start(sessionId?: number): void;
+    end(): void;
+}
+
+declare enum DestinationConnectionMode {
+    Hybrid = "hybrid",
+    Cloud = "cloud",
+    Device = "device"
+}
+type DestinationEvent = {
+    eventName: string;
+};
+type DeviceModeDestination = {
+    name: string;
+    destinationId: string;
+    shouldApplyDeviceModeTransformation: boolean;
+    propagateEventsUntransformedOnError: boolean;
+    analytics: any;
+    [index: string]: any;
+    isLoaded: () => boolean;
+    isReady?: () => boolean;
+};
+type DestinationConfig = {
+    blacklistedEvents: DestinationEvent[];
+    whitelistedEvents: DestinationEvent[];
+    oneTrustCookieCategories: OneTrustCookieCategory[];
+    ketchConsentPurposes: KetchConsentPurpose[];
+    eventFilteringOption: EventFilteringOption;
+    clickEventConversions?: Conversion[];
+    pageLoadConversions?: Conversion[];
+    conversionID?: string;
+    conversionLinker?: boolean;
+    disableAdPersonalization?: boolean;
+    dynamicRemarketing?: boolean;
+    sendPageView?: boolean;
+    defaultPageConversion?: string;
+    enableConversionEventsFiltering?: boolean;
+    trackConversions?: boolean;
+    trackDynamicRemarketing?: boolean;
+    tagID?: string;
+    advertiserId?: string;
+    partnerId?: string;
+    measurementId?: string;
+    capturePageView?: string;
+    useNativeSDKToSend?: boolean;
+    connectionMode?: DestinationConnectionMode;
+    extendPageViewParams?: boolean;
+    eventMappingFromConfig?: EventMapping[];
+    appKey?: string;
+    dataCenter?: string;
+    enableBrazeLogging?: boolean;
+    enableNestedArrayOperations?: boolean;
+    enableSubscriptionGroupInGroupCall?: boolean;
+    supportDedup?: boolean;
+    trackAnonymousUser?: boolean;
+    serverUrl?: string;
+    containerID?: string;
+    fs_debug_mode?: boolean;
+    fs_org?: boolean;
+    siteID?: string;
+    [key: string]: any;
+};
+type Destination = {
+    id: string;
+    displayName: string;
+    userFriendlyId: string;
+    shouldApplyDeviceModeTransformation: boolean;
+    propagateEventsUntransformedOnError: boolean;
+    config: DestinationConfig;
+    instance?: DeviceModeDestination;
+};
+
+type StatsCollection = {
+    errors: {
+        enabled: boolean;
+        provider?: string;
+    };
+    metrics: {
+        enabled: boolean;
+    };
+};
+type SourceConfig = {
+    statsCollection?: StatsCollection;
+};
+type Source = {
+    id: string;
+    config?: SourceConfig;
+    dataplanes?: Record<ResidencyServerRegion, RegionDetails[]>;
+};
+
+interface IConfigManager {
+    httpClient: IHttpClient;
+    errorHandler?: IErrorHandler;
+    logger?: ILogger;
+    init: () => void;
+    getConfig: () => void;
+    processConfig: () => void;
+}
+
+interface IEventManager {
+    init(): void;
+    addEvent(event: APIEvent): void;
+}
+
+interface ICapabilitiesManager {
+    logger?: ILogger;
+    errorHandler?: IErrorHandler;
+    externalSrcLoader?: IExternalSrcLoader;
+    init(): void;
+    detectBrowserCapabilities(): void;
+    prepareBrowserCapabilities(): void;
+    attachWindowListeners(): void;
+    onReady(): void;
+}
+
+type PreloadedEventCall = Array<string | any>;
+
+/**
+ * A buffer queue to serve as a store for any type of data
+ */
+declare class BufferQueue<T = any> {
+    items: T[];
+    constructor();
+    enqueue(item: T): void;
+    dequeue(): Nullable<T> | undefined;
+    isEmpty(): boolean;
+    size(): number;
+    clear(): void;
+}
+//# sourceMappingURL=BufferQueue.d.ts.map
+
+interface IAnalytics {
+    preloadBuffer: BufferQueue<PreloadedEventCall>;
+    initialized: boolean;
+    status?: LifecycleStatus;
+    httpClient: IHttpClient;
+    logger: ILogger;
+    errorHandler: IErrorHandler;
+    externalSrcLoader: IExternalSrcLoader;
+    capabilitiesManager: ICapabilitiesManager;
+    storeManager?: IStoreManager;
+    configManager?: IConfigManager;
+    eventManager?: IEventManager;
+    userSessionManager?: IUserSessionManager;
+    pluginsManager?: IPluginsManager;
+    clientDataStore?: Store;
+    /**
+     * Start application lifecycle if not already started
+     */
+    load(writeKey: string, dataPlaneUrl?: string | Partial<LoadOptions>, loadOptions?: Partial<LoadOptions>): void;
+    /**
+     * Orchestrate the lifecycle of the application phases/status
+     */
+    startLifecycle(): void;
+    /**
+     * Load browser polyfill if required
+     */
+    prepareBrowserCapabilities(): void;
+    /**
+     * Enqueue in buffer the events that were triggered pre SDK initialization
+     */
+    enqueuePreloadBufferEvents(bufferedEvents: PreloadedEventCall[]): void;
+    /**
+     * Start the process of consuming the buffered events that were triggered pre SDK initialization
+     */
+    processDataInPreloadBuffer(): void;
+    /**
+     * Assign instances for the internal services
+     */
+    prepareInternalServices(): void;
+    /**
+     * Load configuration
+     */
+    loadConfig(): void;
+    /**
+     * Initialize the storage and event queue
+     */
+    init(): void;
+    /**
+     * Load plugins
+     */
+    loadPlugins(): void;
+    /**
+     * Trigger onLoaded callback if any is provided in config & emit initialised event
+     */
+    onInitialized(): void;
+    /**
+     * Emit ready event
+     */
+    onReady(): void;
+    /**
+     * Consume preloaded events buffer
+     */
+    processBufferedEvents(): void;
+    /**
+     * Load device mode destinations
+     */
+    loadDestinations(): void;
+    /**
+     * Invoke the ready callbacks if any exist
+     */
+    onDestinationsReady(): void;
+    /**
+     * To register a callback for SDK ready state
+     */
+    ready(callback: ApiCallback): void;
+    /**
+     * To record a page view event
+     */
+    page(pageOptions: PageCallOptions): void;
+    /**
+     * To record a user track event
+     */
+    track(trackCallOptions: TrackCallOptions): void;
+    /**
+     * To record a user identification event
+     */
+    identify(identifyCallOptions: IdentifyCallOptions): void;
+    /**
+     * To record a user alias event
+     */
+    alias(aliasCallOptions: AliasCallOptions): void;
+    /**
+     * To record a user group event
+     */
+    group(groupCallOptions: GroupCallOptions): void;
+    /**
+     * To get anonymousId set in the SDK
+     */
+    getAnonymousId(options?: AnonymousIdOptions): string | undefined;
+    /**
+     * To set anonymousId
+     */
+    setAnonymousId(anonymousId?: string, rudderAmpLinkerParam?: string): void;
+    /**
+     * Clear user information, optionally anonymousId as well
+     */
+    reset(resetAnonymousId?: boolean): void;
+    /**
+     * To get userId set in the SDK
+     */
+    getUserId(): Nullable<string> | undefined;
+    /**
+     * To get user traits set in the SDK
+     */
+    getUserTraits(): Nullable<ApiObject> | undefined;
+    /**
+     * To get groupId set in the SDK
+     */
+    getGroupId(): Nullable<string> | undefined;
+    /**
+     * To get group traits set in the SDK
+     */
+    getGroupTraits(): Nullable<ApiObject> | undefined;
+    /**
+     * To manually start user session in the SDK
+     */
+    startSession(sessionId?: number): void;
+    /**
+     * To manually end user session in the SDK
+     */
+    endSession(): void;
+    /**
+     * To fetch the current sessionId
+     */
+    getSessionId(): Nullable<number>;
+}
+
+declare class RudderAnalytics implements IRudderAnalytics<IAnalytics> {
+    static globalSingleton: Nullable<RudderAnalytics>;
+    analyticsInstances: Record<string, IAnalytics>;
+    defaultAnalyticsKey: string;
+    logger: Logger;
+    constructor();
+    /**
+     * Set instance to use if no specific writeKey is provided in methods
+     * automatically for the first created instance
+     * TODO: to support multiple analytics instances in the near future
+     */
+    setDefaultInstanceKey(writeKey: string): void;
+    /**
+     * Retrieve an existing analytics instance
+     */
+    getAnalyticsInstance(writeKey?: string): IAnalytics;
+    /**
+     * Create new analytics instance and trigger application lifecycle start
+     */
+    load(writeKey: string, dataPlaneUrl: string, loadOptions?: Partial<LoadOptions>): void;
+    /**
+     * Get preloaded events in buffer queue if exists
+     */
+    getPreloadBuffer(): void;
+    /**
+     * Trigger load event in buffer queue if exists
+     */
+    triggerBufferedLoadEvent(): void;
+    /**
+     * Get ready callback arguments and forward to ready call
+     */
+    ready(callback: ApiCallback): void;
+    /**
+     * Process page arguments and forward to page call
+     */
+    page(category?: string | Nullable<ApiObject> | ApiCallback, name?: string | Nullable<ApiOptions> | Nullable<ApiObject> | ApiCallback, properties?: Nullable<ApiOptions> | Nullable<ApiObject> | ApiCallback, options?: Nullable<ApiOptions> | ApiCallback, callback?: ApiCallback): void;
+    /**
+     * Process track arguments and forward to page call
+     */
+    track(event: string, properties?: Nullable<ApiObject> | ApiCallback, options?: Nullable<ApiOptions> | ApiCallback, callback?: ApiCallback): void;
+    /**
+     * Process identify arguments and forward to page call
+     */
+    identify(userId?: string | number | Nullable<ApiObject>, traits?: Nullable<ApiObject> | ApiCallback, options?: Nullable<ApiOptions> | ApiCallback, callback?: ApiCallback): void;
+    /**
+     * Process alias arguments and forward to page call
+     */
+    alias(to?: Nullable<string> | ApiCallback, from?: string | Nullable<ApiOptions> | ApiCallback, options?: Nullable<ApiOptions> | ApiCallback, callback?: ApiCallback): void;
+    /**
+     * Process group arguments and forward to page call
+     */
+    group(groupId: string | number | Nullable<ApiObject> | ApiCallback, traits?: Nullable<ApiOptions> | Nullable<ApiObject> | ApiCallback, options?: Nullable<ApiOptions> | ApiCallback, callback?: ApiCallback): void;
+    reset(resetAnonymousId?: boolean): void;
+    getAnonymousId(options?: AnonymousIdOptions): string | undefined;
+    setAnonymousId(anonymousId?: string, rudderAmpLinkerParam?: string): void;
+    getUserId(): Nullable<string> | undefined;
+    getUserTraits(): Nullable<ApiObject> | undefined;
+    getGroupId(): Nullable<string> | undefined;
+    getGroupTraits(): Nullable<ApiObject> | undefined;
+    startSession(sessionId?: number): void;
+    endSession(): void;
+    getSessionId(): Nullable<number>;
+}
+//# sourceMappingURL=RudderAnalytics.d.ts.map
+
+type AppInfo = {
+    readonly name: string;
+    readonly version: string;
+    readonly namespace: string;
+};
+type LibraryInfo = {
+    readonly name: string;
+    readonly version: string;
+};
+type OSInfo = {
+    readonly name: string;
+    readonly version: string;
+};
+type ScreenInfo = {
+    readonly density: number;
+    readonly width: number;
+    readonly height: number;
+    readonly innerWidth: number;
+    readonly innerHeight: number;
+};
+
+type BufferedEvent = any[];
+
+type SessionInfo = {
+    autoTrack?: boolean;
+    manualTrack?: boolean;
+    timeout?: number;
+    expiresAt?: number;
+    id?: number;
+    sessionStart?: boolean;
+};
+
+type CapabilitiesState = {
+    isOnline: Signal<boolean>;
+    storage: {
+        isLocalStorageAvailable: Signal<boolean>;
+        isCookieStorageAvailable: Signal<boolean>;
+        isSessionStorageAvailable: Signal<boolean>;
+    };
+    isBeaconAvailable: Signal<boolean>;
+    isLegacyDOM: Signal<boolean>;
+    isUaCHAvailable: Signal<boolean>;
+    isCryptoAvailable: Signal<boolean>;
+    isIE11: Signal<boolean>;
+    isAdBlocked: Signal<boolean>;
+};
+type ConsentsState = {
+    data: Signal<ConsentInfo>;
+    activeConsentManagerPluginName: Signal<PluginName | undefined>;
+    preConsentOptions: Signal<PreConsentOptions>;
+};
+type ContextState = {
+    app: Signal<AppInfo>;
+    traits: Signal<Nullable<Traits>>;
+    library: Signal<LibraryInfo>;
+    userAgent: Signal<Nullable<string>>;
+    device: Signal<Nullable<any>>;
+    network: Signal<Nullable<any>>;
+    os: Signal<OSInfo>;
+    locale: Signal<Nullable<string>>;
+    screen: Signal<ScreenInfo>;
+    'ua-ch': Signal<UADataValues | undefined>;
+};
+type EventBufferState = {
+    toBeProcessedArray: Signal<BufferedEvent[]>;
+    readyCallbacksArray: Signal<ApiCallback[]>;
+};
+type LifecycleState = {
+    activeDataplaneUrl: Signal<string | undefined>;
+    integrationsCDNPath: Signal<string | undefined>;
+    pluginsCDNPath: Signal<string | undefined>;
+    sourceConfigUrl: Signal<string | undefined>;
+    status: Signal<LifecycleStatus | undefined>;
+    initialized: Signal<boolean>;
+    logLevel: Signal<LogLevel>;
+    loaded: Signal<boolean>;
+    readyCallbacks: Signal<ReadyCallback[]>;
+    writeKey: Signal<string | undefined>;
+    dataPlaneUrl: Signal<string | undefined>;
+};
+type LoadOptionsState = Signal<LoadOptions>;
+type MetricsState = {
+    retries: Signal<number>;
+    dropped: Signal<number>;
+    sent: Signal<number>;
+    queued: Signal<number>;
+    triggered: Signal<number>;
+};
+type NativeDestinationsState = {
+    configuredDestinations: Signal<Destination[]>;
+    activeDestinations: Signal<Destination[]>;
+    loadOnlyIntegrations: Signal<IntegrationOpts>;
+    failedDestinations: Signal<Destination[]>;
+    loadIntegration: Signal<boolean>;
+    initializedDestinations: Signal<Destination[]>;
+    clientDestinationsReady: Signal<boolean>;
+    integrationsConfig: Signal<IntegrationOpts>;
+};
+type PluginsState = {
+    ready: Signal<boolean>;
+    loadedPlugins: Signal<string[]>;
+    failedPlugins: Signal<string[]>;
+    pluginsToLoadFromConfig: Signal<string[]>;
+    activePlugins: Signal<string[]>;
+    totalPluginsToLoad: Signal<number>;
+};
+type ReportingState = {
+    isErrorReportingEnabled: Signal<boolean>;
+    isMetricsReportingEnabled: Signal<boolean>;
+    errorReportingProviderPluginName: Signal<PluginName | undefined>;
+};
+type SessionState = {
+    readonly userId: Signal<Nullable<string> | undefined>;
+    readonly userTraits: Signal<Nullable<ApiObject> | undefined>;
+    readonly anonymousId: Signal<string | undefined>;
+    readonly groupId: Signal<Nullable<string> | undefined>;
+    readonly groupTraits: Signal<Nullable<ApiObject> | undefined>;
+    readonly initialReferrer: Signal<string | undefined>;
+    readonly initialReferringDomain: Signal<string | undefined>;
+    readonly sessionInfo: Signal<SessionInfo>;
+};
+type SourceConfigState = Signal<Source | undefined>;
+type StorageEntry = {
+    type: StorageType;
+    key: string;
+};
+type StorageEntries = {
+    [key in UserSessionKeys]?: StorageEntry;
+};
+type StorageState = {
+    encryptionPluginName: Signal<PluginName | undefined>;
+    migrate: Signal<boolean>;
+    type: Signal<StorageType | undefined>;
+    cookie: Signal<CookieOptions | undefined>;
+    entries: Signal<StorageEntries>;
+    trulyAnonymousTracking: Signal<boolean>;
+};
+interface ApplicationState {
+    capabilities: CapabilitiesState;
+    consents: ConsentsState;
+    context: ContextState;
+    eventBuffer: EventBufferState;
+    lifecycle: LifecycleState;
+    loadOptions: LoadOptionsState;
+    metrics: MetricsState;
+    nativeDestinations: NativeDestinationsState;
+    plugins: PluginsState;
+    reporting: ReportingState;
+    session: SessionState;
+    source: SourceConfigState;
+    storage: StorageState;
+}
+
+/**
+ * Exposed values that can be accessed as global objects per analytics instance
+ * TODO: find all values that need to be exposed in globals if anything else
+ */
+type ExposedGlobals = {
+    state?: ApplicationState;
+    preloadedEventsBuffer?: PreloadedEventCall[];
+    pluginsCDNPath?: string;
+    [key: string]: any;
+};
+/**
+ * Exposing all globally accessible values for all analytics instances
+ * As key, we use the value of writeKey assigned to analytics instance that the values belong to
+ */
+interface IRudderStackGlobals {
+    [key: string]: ExposedGlobals;
+}
+
+export { type AnonymousIdOptions, type ApiCallback, type ApiObject, type ApiOptions, type BeaconQueueOpts, CookieSameSite, type DestinationsQueueOpts, type IRudderStackGlobals, type IntegrationOpts, type LoadOptions, LogLevel, PluginName, type PreloadedEventCall, type QueueOpts, ResidencyServerRegion, RudderAnalytics, type SessionOpts, UaChTrackLevel };