@rudderstack/analytics-js 3.0.0-beta.1 → 3.0.0-beta.10

package/dist/npm/index.d.ts

@@ -0,0 +1,1166 @@
+/// <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<'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;
+}
+type LogLevel = 'LOG' | 'INFO' | 'DEBUG' | 'WARN' | 'ERROR' | 'NONE';
+
+type RegionDetails = {
+    url: string;
+    default: boolean;
+};
+/**
+ * Represents residency server input the options
+ */
+type ResidencyServerRegion = 'US' | '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;
+}
+type PluginName = 'BeaconQueue' | 'Bugsnag' | 'DeviceModeDestinations' | 'DeviceModeTransformation' | 'ErrorReporting' | 'ExternalAnonymousId' | 'GoogleLinker' | 'KetchConsentManager' | 'NativeDestinationQueue' | 'OneTrustConsentManager' | 'StorageEncryption' | 'StorageEncryptionLegacy' | 'StorageMigrator' | '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>;
+};
+type RudderEventType = 'page' | 'track' | 'identify' | 'alias' | '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;
+};
+
+type UserSessionKeys = 'userId' | 'userTraits' | 'anonymousId' | 'groupId' | 'groupTraits' | 'initialReferrer' | 'initialReferringDomain' | 'sessionInfo';
+
+type StorageEncryptionVersion = 'legacy' | '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;
+};
+type CookieSameSite = 'Strict' | 'Lax' | 'None';
+
+type UaChTrackLevel = 'none' | 'default' | '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;
+};
+type EventsTransportMode = 'xhr' | 'beacon';
+type BatchOpts = {
+    enabled: boolean;
+    maxItems?: number;
+    maxSize?: number;
+    flushInterval?: number;
+};
+/**
+ * Represents the queue options parameter in loadOptions type
+ */
+type QueueOpts = {
+    maxRetryDelay?: number;
+    minRetryDelay?: number;
+    backoffFactor?: number;
+    backoffJitter?: number;
+    maxAttempts?: number;
+    maxItems?: number;
+    batch?: BatchOpts;
+};
+/**
+ * Represents the destinations queue options parameter in loadOptions type
+ */
+type DestinationsQueueOpts = {
+    maxItems?: number;
+};
+type OnLoadedCallback = (analytics: any) => void;
+type DeliveryType = 'immediate' | 'buffer';
+type StorageStrategy = 'none' | 'session' | '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;
+    transportMode?: EventsTransportMode;
+};
+
+type LoggerProvider = Record<Exclude<Lowercase<LogLevel>, Lowercase<'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;
+}
+
+type LifecycleStatus = 'mounted' | 'browserCapabilitiesReady' | 'configured' | 'pluginsLoading' | 'pluginsReady' | 'initialized' | 'loaded' | 'destinationsLoading' | 'destinationsReady' | '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;
+}
+
+type DestinationConnectionMode = 'hybrid' | 'cloud' | '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, type CookieSameSite, type DestinationsQueueOpts, type IRudderStackGlobals, type IntegrationOpts, type LoadOptions, type LogLevel, type PluginName, type PreloadedEventCall, type QueueOpts, type ResidencyServerRegion, RudderAnalytics, type SessionOpts, type UaChTrackLevel };