@rudderstack/analytics-js 3.0.0-beta.9 → 3.0.1

package/dist/npm/index.d.ts

@@ -1,7 +1,7 @@
 /// <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>;
+type LoggerProvider$1 = Record<Exclude<Lowercase<LogLevel>, Lowercase<'NONE'>>, (...data: any[]) => void>;
 interface ILogger {
     minLogLevel: number;
     scope?: string;
@@ -14,85 +14,33 @@ interface ILogger {
     setScope(scopeVal: string): void;
     setMinLogLevel(logLevel: LogLevel): void;
 }
-declare enum LogLevel {
-    Log = "LOG",
-    Info = "INFO",
-    Debug = "DEBUG",
-    Warn = "WARN",
-    Error = "ERROR",
-    None = "NONE"
-}
+type LogLevel = 'LOG' | 'INFO' | 'DEBUG' | 'WARN' | 'ERROR' | '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;
+type LoggerProvider = Record<Exclude<Lowercase<LogLevel>, Lowercase<'NONE'>>, (...data: any[]) => void>;
 
-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.
+ * Service to log messages/data to output provider, default is console
  */
-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>[];
-}
+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
 
-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"
-}
+type Nullable<T> = T | null;
 
 /**
  * Represents a generic object in the APIs
@@ -139,47 +87,90 @@ type APIEvent = {
     from?: string;
     groupId?: Nullable<string>;
 };
-declare enum RudderEventType {
-    Page = "page",
-    Track = "track",
-    Identify = "identify",
-    Alias = "alias",
-    Group = "group"
-}
+type RudderEventType = 'page' | 'track' | 'identify' | 'alias' | 'group';
 type ReadyCallback = () => void;
 
+type RegionDetails = {
+    url: string;
+    default: boolean;
+};
+/**
+ * Represents residency server input the options
+ */
+type ResidencyServerRegion = 'US' | 'EU';
+
+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' | 'CustomConsentManager' | 'DeviceModeDestinations' | 'DeviceModeTransformation' | 'ErrorReporting' | 'ExternalAnonymousId' | 'GoogleLinker' | 'KetchConsentManager' | 'NativeDestinationQueue' | 'OneTrustConsentManager' | 'StorageEncryption' | 'StorageEncryptionLegacy' | 'StorageMigrator' | 'XhrQueue';
+
 type OneTrustCookieCategory = {
     oneTrustCookieCategory: string;
 };
-type CookieConsentOptions = {
-    [key: string]: {
-        enabled: boolean;
-    };
+type ConsentManagementMetadata = {
+    providers: ConsentManagementProviderMetadata[];
 };
-type ConsentInfo = {
-    initialized: boolean;
-    allowedConsents?: Record<string, string> | string[];
-    deniedConsentIds?: string[];
+type ConsentManagementProviderMetadata = {
+    provider: ConsentManagementProvider;
+    resolutionStrategy: ConsentResolutionStrategy;
+};
+type ConsentManagementProvider = 'oneTrust' | 'ketch' | 'custom';
+type ConsentResolutionStrategy = 'and' | 'or';
+type Consents = string[];
+type ConsentManagementOptions = {
+    enabled: boolean;
+    provider: ConsentManagementProvider;
+    allowedConsentIds?: Consents;
+    deniedConsentIds?: Consents;
+};
+type ConsentsInfo = {
+    allowedConsentIds?: Consents;
+    deniedConsentIds?: Consents;
 };
 type KetchConsentPurpose = {
     purpose: string;
 };
 
-declare enum UserSessionKeys {
-    userId = "userId",
-    userTraits = "userTraits",
-    anonymousId = "anonymousId",
-    groupId = "groupId",
-    groupTraits = "groupTraits",
-    initialReferrer = "initialReferrer",
-    initialReferringDomain = "initialReferringDomain",
-    sessionInfo = "sessionInfo"
-}
+type UserSessionKey = 'userId' | 'userTraits' | 'anonymousId' | 'groupId' | 'groupTraits' | 'initialReferrer' | 'initialReferringDomain' | 'sessionInfo' | 'authToken';
 
-declare enum StorageEncryptionVersion {
-    Legacy = "legacy",
-    V3 = "v3"
-}
+type StorageEncryptionVersion = 'legacy' | 'v3';
 type StorageType = 'cookieStorage' | 'localStorage' | 'memoryStorage' | 'sessionStorage' | 'none';
 type StorageEncryption = {
     version: StorageEncryptionVersion;
@@ -193,7 +184,7 @@ type StorageOpts = {
     type?: StorageType;
     cookie?: CookieOptions;
     entries?: {
-        [key in UserSessionKeys]?: LoadOptionStorageEntry;
+        [key in UserSessionKey]?: LoadOptionStorageEntry;
     };
 };
 type CookieOptions = {
@@ -204,17 +195,9 @@ type CookieOptions = {
     samesite?: string;
     secure?: boolean;
 };
-declare enum CookieSameSite {
-    Strict = "Strict",
-    Lax = "Lax",
-    None = "None"
-}
+type CookieSameSite = 'Strict' | 'Lax' | 'None';
 
-declare enum UaChTrackLevel {
-    None = "none",
-    Default = "default",
-    Full = "full"
-}
+type UaChTrackLevel = 'none' | 'default' | 'full';
 /**
  * Represents the options parameter for anonymousId
  */
@@ -244,6 +227,13 @@ 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
  */
@@ -251,8 +241,10 @@ 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
@@ -261,15 +253,8 @@ 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 DeliveryType = 'immediate' | 'buffer';
+type StorageStrategy = 'none' | 'session' | 'anonymousId';
 type PreConsentStorageOptions = {
     strategy: StorageStrategy;
 };
@@ -280,7 +265,6 @@ type PreConsentOptions = {
     enabled: boolean;
     storage?: PreConsentStorageOptions;
     events?: PreConsentEventsOptions;
-    trackConsent?: boolean;
 };
 /**
  * Represents the options parameter in the load API
@@ -288,22 +272,21 @@ type PreConsentOptions = {
 type LoadOptions = {
     logLevel?: LogLevel;
     integrations?: IntegrationOpts;
-    configUrl: string;
+    configUrl?: string;
     queueOptions?: QueueOpts;
     loadIntegration?: boolean;
-    sessions: SessionOpts;
+    sessions?: SessionOpts;
     secureCookie?: boolean;
     destSDKBaseURL?: string;
     pluginsSDKBaseURL?: string;
     useBeacon?: boolean;
     beaconQueueOptions?: BeaconQueueOpts;
     destinationsQueueOptions?: DestinationsQueueOpts;
-    cookieConsentManager?: CookieConsentOptions;
     anonymousIdOptions?: AnonymousIdOptions;
     setCookieDomain?: string;
-    sameSiteCookie: CookieSameSite;
+    sameSiteCookie?: CookieSameSite;
     lockIntegrationsVersion?: boolean;
-    polyfillIfRequired: boolean;
+    polyfillIfRequired?: boolean;
     onLoaded?: OnLoadedCallback;
     uaChTrackLevel?: UaChTrackLevel;
     residencyServer?: ResidencyServerRegion;
@@ -317,38 +300,107 @@ type LoadOptions = {
     dataPlaneEventsBufferTimeout?: number;
     storage?: StorageOpts;
     preConsent?: PreConsentOptions;
+    transportMode?: EventsTransportMode;
+    consentManagement?: ConsentManagementOptions;
+    sameDomainCookiesOnly?: boolean;
+    externalAnonymousIdCookieName?: string;
+};
+type ConsentOptions = {
+    storage?: StorageOpts;
+    consentManagement?: ConsentManagementOptions;
+    integrations?: IntegrationOpts;
+    discardPreConsentEvents?: boolean;
+    sendPageEvent?: boolean;
+    trackConsent?: boolean;
 };
 
-type LoggerProvider = Record<Exclude<Lowercase<LogLevel>, Lowercase<LogLevel.None>>, (...data: any[]) => void>;
-
+type Address = {
+    city?: string;
+    City?: string;
+    country?: string;
+    Country?: string;
+    postalCode?: string;
+    state?: string;
+    State?: string;
+    street?: string;
+};
+type Company = {
+    name?: string;
+    id?: string;
+    industry?: string;
+    employee_count?: string;
+    plan?: string;
+};
 /**
- * Service to log messages/data to output provider, default is console
+ * Represents a traits object in the Identify API
  */
-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 IdentifyTraits = {
+    id?: string;
+    userId?: string;
+    firstName?: string;
+    firstname?: string;
+    first_name?: string;
+    lastName?: string;
+    lastname?: string;
+    last_name?: string;
+    name?: string;
+    Name?: string;
+    age?: number;
+    email?: string;
+    Email?: string;
+    'E-mail'?: string;
+    phone?: string;
+    address?: string | Address;
+    birthday?: string;
+    company?: Company;
+    createdAt?: string;
+    description?: string;
+    gender?: string;
+    title?: string;
+    username?: string;
+    website?: string;
+    avatar?: string;
+    zip?: string | number;
+    state?: string;
+    State?: string;
+    dob?: string;
+    employed?: string | boolean;
+    education?: string;
+    married?: string | boolean;
+    customerType?: string | number;
+    euConsent?: string;
+    euConsentMessage?: string;
+    newEmail?: string;
+    tags?: string | string[];
+    removeTags?: string | string[];
+    prospect?: string | boolean;
+    doubleOptin?: string | boolean;
+    event_id?: string;
+    constructor?: Record<string, string>;
+    organization?: string;
+    region?: string;
+    anonymous?: string | boolean;
+    country?: string;
+    custom?: string;
+    ip?: string;
+    privateAttributeNames?: any;
+    secondary?: any;
+    customPageId?: string;
+    isRudderEvents?: boolean;
+    optOutType?: boolean | string | number;
+    groupType?: string | number;
+    anonymousId?: string | number;
+    ip_address?: string;
+    number?: string | number;
+    [index: string]: string | number | boolean | ApiObject | null | (string | number | boolean | null | ApiObject)[] | undefined;
+};
 
 type AnalyticsIdentifyMethod = {
-    (userId?: string, traits?: Nullable<ApiObject>, options?: Nullable<ApiOptions>, callback?: ApiCallback): void;
-    (userId: string, traits: Nullable<ApiObject>, callback: ApiCallback): void;
+    (userId?: string, traits?: Nullable<IdentifyTraits>, options?: Nullable<ApiOptions>, callback?: ApiCallback): void;
+    (userId: string, traits: Nullable<IdentifyTraits>, callback: ApiCallback): void;
     (userId: string, callback: ApiCallback): void;
-    (traits: Nullable<ApiObject>, options: Nullable<ApiOptions>, callback?: ApiCallback): void;
-    (traits: Nullable<ApiObject>, callback?: ApiCallback): void;
+    (traits: Nullable<IdentifyTraits>, options: Nullable<ApiOptions>, callback?: ApiCallback): void;
+    (traits: Nullable<IdentifyTraits>, callback?: ApiCallback): void;
 };
 type AnalyticsPageMethod = {
     (category?: string, name?: string, properties?: Nullable<ApiObject>, options?: Nullable<ApiOptions>, callback?: ApiCallback): void;
@@ -467,10 +519,20 @@ interface IRudderAnalytics<T = any> {
      * To manually end user session in the SDK
      */
     endSession(): void;
+    /**
+     * To set authorization token
+     * @param token token value
+     */
+    setAuthToken(token: string): void;
     /**
      * To fetch the current sessionId
      */
     getSessionId(): Nullable<number>;
+    /**
+     * To provide consent
+     * @param options Consent API options
+     */
+    consent(options?: ConsentOptions): void;
 }
 
 interface IExternalSourceLoadConfig {
@@ -492,15 +554,42 @@ interface IExternalSrcLoader {
     loadJSFile(config: IExternalSourceLoadConfig): void;
 }
 
-type SDKError = unknown;
+/**
+ * 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
+
+type SDKError = unknown | Error | ErrorEvent | Event | PromiseRejectionEvent;
 interface IErrorHandler {
     logger?: ILogger;
     pluginEngine?: IPluginEngine;
+    errorBuffer: BufferQueue<PreLoadErrorData>;
     init(externalSrcLoader: IExternalSrcLoader): void;
-    onError(error: SDKError, context?: string, customMessage?: string, shouldAlwaysThrow?: boolean): void;
+    onError(error: SDKError, context?: string, customMessage?: string, shouldAlwaysThrow?: boolean, errorType?: string): void;
     leaveBreadcrumb(breadcrumb: string): void;
     notifyError(error: Error): void;
+    attachErrorListeners(): void;
 }
+type ErrorState = {
+    severity: string;
+    unhandled: boolean;
+    severityReason: {
+        type: string;
+    };
+};
+type PreLoadErrorData = {
+    error: SDKError;
+    errorState: ErrorState;
+};
 
 interface IRequestConfig {
     url: string;
@@ -539,19 +628,6 @@ interface IHttpClient {
     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;
@@ -569,7 +645,7 @@ interface IStoreManager {
     errorHandler?: IErrorHandler;
     logger?: ILogger;
     init(): void;
-    initClientDataStore(): void;
+    initializeStorageState(): void;
     setStore(storeConfig: IStoreConfig): IStore;
     getStore(id: StoreId): IStore | undefined;
 }
@@ -606,6 +682,7 @@ interface ICookieStorageOptions extends CookieOptions {
     domain?: string;
     secure?: boolean;
     enabled?: boolean;
+    sameDomainCookiesOnly?: boolean;
 }
 interface ILocalStorageOptions {
     enabled?: boolean;
@@ -629,7 +706,7 @@ type TrackCallOptions = {
 };
 type IdentifyCallOptions = {
     userId?: string | null;
-    traits?: Nullable<ApiObject>;
+    traits?: Nullable<IdentifyTraits>;
     options?: Nullable<ApiOptions>;
     callback?: ApiCallback;
 };
@@ -724,13 +801,11 @@ interface IUserSessionManager {
     reset(resetAnonymousId?: boolean, noNewSessionStart?: boolean): void;
     start(sessionId?: number): void;
     end(): void;
+    syncStorageDataToState(): void;
+    setAuthToken(token: Nullable<string>): void;
 }
 
-declare enum DestinationConnectionMode {
-    Hybrid = "hybrid",
-    Cloud = "cloud",
-    Device = "device"
-}
+type DestinationConnectionMode = 'hybrid' | 'cloud' | 'device';
 type DestinationEvent = {
     eventName: string;
 };
@@ -744,11 +819,20 @@ type DeviceModeDestination = {
     isLoaded: () => boolean;
     isReady?: () => boolean;
 };
+type ConsentsConfig = {
+    consent: string;
+};
+type ConsentManagementProviderConfig = {
+    provider: ConsentManagementProvider;
+    consents: ConsentsConfig[];
+    resolutionStrategy: string | undefined;
+};
 type DestinationConfig = {
     blacklistedEvents: DestinationEvent[];
     whitelistedEvents: DestinationEvent[];
-    oneTrustCookieCategories: OneTrustCookieCategory[];
-    ketchConsentPurposes: KetchConsentPurpose[];
+    oneTrustCookieCategories?: OneTrustCookieCategory[];
+    ketchConsentPurposes?: KetchConsentPurpose[];
+    consentManagement?: ConsentManagementProviderConfig[];
     eventFilteringOption: EventFilteringOption;
     clickEventConversions?: Conversion[];
     pageLoadConversions?: Conversion[];
@@ -824,6 +908,7 @@ interface IConfigManager {
 interface IEventManager {
     init(): void;
     addEvent(event: APIEvent): void;
+    resume(): void;
 }
 
 interface ICapabilitiesManager {
@@ -838,25 +923,13 @@ interface ICapabilitiesManager {
 }
 
 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
+type RudderAnalyticsPreloader = {
+    [index: string]: (...args: number[]) => any;
+};
 
 interface IAnalytics {
     preloadBuffer: BufferQueue<PreloadedEventCall>;
     initialized: boolean;
-    status?: LifecycleStatus;
     httpClient: IHttpClient;
     logger: ILogger;
     errorHandler: IErrorHandler;
@@ -879,7 +952,11 @@ interface IAnalytics {
     /**
      * Load browser polyfill if required
      */
-    prepareBrowserCapabilities(): void;
+    onMounted(): void;
+    /**
+     * Prepare internal services and load configuration
+     */
+    onBrowserCapabilitiesReady(): void;
     /**
      * Enqueue in buffer the events that were triggered pre SDK initialization
      */
@@ -899,11 +976,11 @@ interface IAnalytics {
     /**
      * Initialize the storage and event queue
      */
-    init(): void;
+    onPluginsReady(): void;
     /**
      * Load plugins
      */
-    loadPlugins(): void;
+    onConfigured(): void;
     /**
      * Trigger onLoaded callback if any is provided in config & emit initialised event
      */
@@ -927,27 +1004,27 @@ interface IAnalytics {
     /**
      * To register a callback for SDK ready state
      */
-    ready(callback: ApiCallback): void;
+    ready(callback: ApiCallback, isBufferedInvocation?: boolean): void;
     /**
      * To record a page view event
      */
-    page(pageOptions: PageCallOptions): void;
+    page(pageOptions: PageCallOptions, isBufferedInvocation?: boolean): void;
     /**
      * To record a user track event
      */
-    track(trackCallOptions: TrackCallOptions): void;
+    track(trackCallOptions: TrackCallOptions, isBufferedInvocation?: boolean): void;
     /**
      * To record a user identification event
      */
-    identify(identifyCallOptions: IdentifyCallOptions): void;
+    identify(identifyCallOptions: IdentifyCallOptions, isBufferedInvocation?: boolean): void;
     /**
      * To record a user alias event
      */
-    alias(aliasCallOptions: AliasCallOptions): void;
+    alias(aliasCallOptions: AliasCallOptions, isBufferedInvocation?: boolean): void;
     /**
      * To record a user group event
      */
-    group(groupCallOptions: GroupCallOptions): void;
+    group(groupCallOptions: GroupCallOptions, isBufferedInvocation?: boolean): void;
     /**
      * To get anonymousId set in the SDK
      */
@@ -955,11 +1032,11 @@ interface IAnalytics {
     /**
      * To set anonymousId
      */
-    setAnonymousId(anonymousId?: string, rudderAmpLinkerParam?: string): void;
+    setAnonymousId(anonymousId?: string, rudderAmpLinkerParam?: string, isBufferedInvocation?: boolean): void;
     /**
      * Clear user information, optionally anonymousId as well
      */
-    reset(resetAnonymousId?: boolean): void;
+    reset(resetAnonymousId?: boolean, isBufferedInvocation?: boolean): void;
     /**
      * To get userId set in the SDK
      */
@@ -979,15 +1056,24 @@ interface IAnalytics {
     /**
      * To manually start user session in the SDK
      */
-    startSession(sessionId?: number): void;
+    startSession(sessionId?: number, isBufferedInvocation?: boolean): void;
     /**
      * To manually end user session in the SDK
      */
-    endSession(): void;
+    endSession(isBufferedInvocation?: boolean): void;
     /**
      * To fetch the current sessionId
      */
     getSessionId(): Nullable<number>;
+    /**
+     * To record consent
+     * @param options Consent API options
+     */
+    consent(options?: ConsentOptions, isBufferedInvocation?: boolean): void;
+    /**
+     * To set auth token
+     */
+    setAuthToken(token: string): void;
 }
 
 declare class RudderAnalytics implements IRudderAnalytics<IAnalytics> {
@@ -1011,11 +1097,8 @@ declare class RudderAnalytics implements IRudderAnalytics<IAnalytics> {
      */
     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
+     * Trigger load event in buffer queue if exists and stores the
+     * remaining preloaded events array in global object
      */
     triggerBufferedLoadEvent(): void;
     /**
@@ -1033,7 +1116,7 @@ declare class RudderAnalytics implements IRudderAnalytics<IAnalytics> {
     /**
      * 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;
+    identify(userId?: string | number | Nullable<IdentifyTraits>, traits?: Nullable<IdentifyTraits> | Nullable<ApiOptions> | ApiCallback, options?: Nullable<ApiOptions> | ApiCallback, callback?: ApiCallback): void;
     /**
      * Process alias arguments and forward to page call
      */
@@ -1052,6 +1135,8 @@ declare class RudderAnalytics implements IRudderAnalytics<IAnalytics> {
     startSession(sessionId?: number): void;
     endSession(): void;
     getSessionId(): Nullable<number>;
+    setAuthToken(token: string): void;
+    consent(options?: ConsentOptions): void;
 }
 //# sourceMappingURL=RudderAnalytics.d.ts.map
 
@@ -1063,6 +1148,7 @@ type AppInfo = {
 type LibraryInfo = {
     readonly name: string;
     readonly version: string;
+    readonly snippetVersion?: string;
 };
 type OSInfo = {
     readonly name: string;
@@ -1078,6 +1164,8 @@ type ScreenInfo = {
 
 type BufferedEvent = any[];
 
+type LifecycleStatus = 'mounted' | 'browserCapabilitiesReady' | 'configured' | 'pluginsLoading' | 'pluginsReady' | 'initialized' | 'loaded' | 'destinationsLoading' | 'destinationsReady' | 'ready' | 'readyExecuted';
+
 type SessionInfo = {
     autoTrack?: boolean;
     manualTrack?: boolean;
@@ -1102,9 +1190,15 @@ type CapabilitiesState = {
     isAdBlocked: Signal<boolean>;
 };
 type ConsentsState = {
-    data: Signal<ConsentInfo>;
+    enabled: Signal<boolean>;
+    data: Signal<ConsentsInfo>;
+    initialized: Signal<boolean>;
     activeConsentManagerPluginName: Signal<PluginName | undefined>;
-    preConsentOptions: Signal<PreConsentOptions>;
+    preConsent: Signal<PreConsentOptions>;
+    postConsent: Signal<ConsentOptions>;
+    resolutionStrategy: Signal<ConsentResolutionStrategy | undefined>;
+    provider: Signal<ConsentManagementProvider | undefined>;
+    metadata: Signal<ConsentManagementMetadata | undefined>;
 };
 type ContextState = {
     app: Signal<AppInfo>;
@@ -1117,6 +1211,7 @@ type ContextState = {
     locale: Signal<Nullable<string>>;
     screen: Signal<ScreenInfo>;
     'ua-ch': Signal<UADataValues | undefined>;
+    timezone: Signal<string | undefined>;
 };
 type EventBufferState = {
     toBeProcessedArray: Signal<BufferedEvent[]>;
@@ -1165,6 +1260,7 @@ type ReportingState = {
     isErrorReportingEnabled: Signal<boolean>;
     isMetricsReportingEnabled: Signal<boolean>;
     errorReportingProviderPluginName: Signal<PluginName | undefined>;
+    isErrorReportingPluginLoaded: Signal<boolean>;
 };
 type SessionState = {
     readonly userId: Signal<Nullable<string> | undefined>;
@@ -1175,6 +1271,7 @@ type SessionState = {
     readonly initialReferrer: Signal<string | undefined>;
     readonly initialReferringDomain: Signal<string | undefined>;
     readonly sessionInfo: Signal<SessionInfo>;
+    readonly authToken: Signal<Nullable<string>>;
 };
 type SourceConfigState = Signal<Source | undefined>;
 type StorageEntry = {
@@ -1182,7 +1279,7 @@ type StorageEntry = {
     key: string;
 };
 type StorageEntries = {
-    [key in UserSessionKeys]?: StorageEntry;
+    [key in UserSessionKey]?: StorageEntry;
 };
 type StorageState = {
     encryptionPluginName: Signal<PluginName | undefined>;
@@ -1226,4 +1323,14 @@ 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 };
+declare global {
+    interface Window {
+        rudderanalytics: RudderAnalytics | PreloadedEventCall[] | RudderAnalyticsPreloader;
+        RudderStackGlobals: IRudderStackGlobals;
+        rudderAnalyticsMount: () => void;
+        rudderAnalyticsBuildType: 'legacy' | 'modern';
+    }
+}
+//# sourceMappingURL=index.d.ts.map
+
+export { type AnonymousIdOptions, type ApiCallback, type ApiObject, type ApiOptions, type BeaconQueueOpts, type ConsentOptions, type CookieSameSite, type DestinationsQueueOpts, type IRudderStackGlobals, type IdentifyTraits, type IntegrationOpts, type LoadOptions, type LogLevel, type PluginName, type PreloadedEventCall, type QueueOpts, type ResidencyServerRegion, RudderAnalytics, type RudderAnalyticsPreloader, type SessionOpts, type UaChTrackLevel };