@corbado/observe 0.13.0 → 0.15.0

package/dist/index.d.mts

@@ -24,6 +24,8 @@ declare enum AuthEventName {
     SubflowError = "subflow_error",
     SubflowStarted = "subflow_started",
     SubflowFinished = "subflow_finished",
+    /** Client-side flow enrichment (the server accepts `session_enriched` as a legacy alias). */
+    FlowEnriched = "flow_enriched",
     Conversion = "conversion"
 }
 interface BaseEvent {
@@ -51,6 +53,15 @@ interface BaseEvent {
 type UserReference = {
     userId?: string;
     identifier?: string;
+    /** Shared UUID used to link sessions across environments. */
+    crossEnvironmentTransactionID?: string;
+};
+type LegacyUserReference = {
+    /** @deprecated Use tracker.setUser() within the active flow instead. */
+    userId?: string;
+    /** @deprecated Use tracker.setUser() within the active flow instead. */
+    identifier?: string;
+    /** @deprecated Use tracker.setUser() within the active flow instead. */
     crossEnvironmentTransactionID?: string;
 };
 /**
@@ -83,11 +94,11 @@ type Conversion = {
     name: string;
     /** Where the conversion happened, e.g. `"checkout"` or `"product-page"`. */
     touchpoint?: string;
-} & UserReference;
+} & LegacyUserReference;
 type FlowFinished = {
     flowName: FlowType;
     explicitOutcome?: "skipped" | "visible-auto-skip" | "invisible";
-} & UserReference;
+} & LegacyUserReference;
 type FlowReset = {
     flowName?: FlowType;
 };
@@ -97,7 +108,7 @@ type MultiFlowReset = {
 type FlowAutoFinished = {
     flowName: FlowType;
     finishedByFlowName: FlowType;
-} & UserReference;
+} & LegacyUserReference;
 type AuthMethodDecisionStarted = {
     decisionName: string;
     options: (AuthMethodType | (string & {}))[];
@@ -105,15 +116,16 @@ type AuthMethodDecisionStarted = {
 };
 type AuthMethodDecisionFinished = {
     decisionName: string;
-    options: (AuthMethodType | (string & {}))[];
+    /** Optional — when omitted, the backend completes the open decision of the same name using its declared options (classifier follow-up). */
+    options?: (AuthMethodType | (string & {}))[];
     explicitDecisionValue?: string;
 };
 type ProvideIdentifierStart = {};
-type ProvideIdentifierError = UserReference & {
+type ProvideIdentifierError = LegacyUserReference & {
     errorCode?: string;
     error?: any;
 };
-type ProvideIdentifierFinish = UserReference & {
+type ProvideIdentifierFinish = LegacyUserReference & {
     identifierPrefillingCreated?: boolean;
 };
 type PasskeyLoginClientError = {
@@ -125,7 +137,7 @@ type PasskeyLoginStartable = {
 type PasskeyLoginSubmitted = {
     assertionResponse: string;
 };
-type PasskeyLoginFinish = UserReference & {};
+type PasskeyLoginFinish = LegacyUserReference & {};
 type AuthDecisionStarted = {
     decisionName: string;
     options: string[];
@@ -136,6 +148,13 @@ type AuthDecisionFinished = {
     explicitDecisionValue?: string;
 };
 type StepOptions = {
+    /** Semantic control that explicitly initiated this step; omitted when unknown. */
+    initiator?: LowEventInitiator;
+    /** @internal Session captured with the operation start; never sent as event metadata. */
+    captureSessionId?: string;
+    /** @internal Capture anchor supplied by operation helpers. */
+    subflowStartEventId?: string;
+    /** @deprecated Use tracker.setUser() within the active flow instead. */
     userReference?: UserReference;
     explicitTimestamp?: number;
     /** Per-call experiment override (experiment key → variant), merged over the persistent assignments. */
@@ -165,7 +184,22 @@ interface CustomEvent extends BaseEvent {
     data?: Record<string, unknown>;
 }
 type Event = PredefinedEvent | CustomEvent;
+type LowEventSourceKind = "input" | "input-group" | "ceremony" | "window";
+type LowEventFieldRole = "password" | "identifier" | "otp" | "data";
+type LowEventInitiator = `input-${LowEventFieldRole}` | "passkey-button" | "automatic" | "unknown";
+type LowEventInputEffect = "fill" | "modify" | "clear";
 interface LowEvent {
+    /** Per-page uint32 observation order; reserved before batching and retained on retry. */
+    captureSeq?: number;
+    captureVersion?: number;
+    pageId?: string;
+    initiator?: LowEventInitiator;
+    inputEffect?: LowEventInputEffect;
+    /** Immutable delivery identity; absent on legacy records. */
+    id?: string;
+    subflowStartEventId?: string;
+    sourceKind?: LowEventSourceKind;
+    fieldRole?: LowEventFieldRole;
     lowType: string;
     ts: number;
     durationMs?: number;
@@ -220,6 +254,10 @@ interface EventBatchMeta {
     configVersion?: string;
 }
 interface EventMeta {
+    initiator?: LowEventInitiator;
+    captureVersion?: number;
+    pageId?: string;
+    subflowStartEventId?: string;
     trackingSourcePath: string;
     /**
      * Per-tab id (uuidv7, `sessionStorage`-scoped) of the tab that CREATED this event, stamped at
@@ -229,6 +267,8 @@ interface EventMeta {
     tabId?: string;
 }
 interface EventBatch {
+    /** Request durable acceptance for replayable lows. */
+    deliveryAck?: boolean;
     sessionId: string;
     events: Event[];
     sdk: SdkInfo;
@@ -324,6 +364,8 @@ interface SdkReliabilityConfig {
     flushIntervalMs: number;
     /** Persist queued events to a durable outbox so they survive reloads, redirects and context switches. */
     durableOutbox: boolean;
+    /** Persist lows in a separate bounded outbox; defaults to disabled for older configs. */
+    durableLowOutbox?: boolean;
     /** Use keepalive/sendBeacon transport for flushes triggered during page unload. */
     beaconKeepalive: boolean;
     /** Maintain session continuity across reloads/tabs by persisting the session id in localStorage. */
@@ -427,6 +469,41 @@ interface CreateLoggerOptions {
 }
 declare function createLogger(options: CreateLoggerOptions): Logger;
 
+type WindowCaptureContext = Pick<LowEvent, "subflowStartEventId" | "fieldRole" | "initiator"> & {
+    sessionId?: string;
+};
+/** One passive observer per tracker. Field/ceremony collectors register context, not DOM listeners. */
+declare class SharedWindowObserver {
+    private logger;
+    private enqueue;
+    private flushKeepalive;
+    private inputs;
+    private ceremonies;
+    private removers;
+    private lastBlur?;
+    private bracket?;
+    private unrelatedPointerAt;
+    private destroyed;
+    private viewportContext;
+    private resize;
+    private scroll;
+    constructor(logger: Logger, enqueue: (low: LowEvent, sessionId?: string) => void, flushKeepalive: () => void);
+    registerInputs(fields: readonly HTMLInputElement[], context: () => WindowCaptureContext, flush: () => void): () => void;
+    beginCeremony(context: WindowCaptureContext): {
+        settle: (tailMs: number) => void;
+        destroy: () => void;
+    };
+    private context;
+    private findInput;
+    /** Flush all registered input batches before a high-level lifecycle boundary. */
+    flushInputs(): void;
+    private emit;
+    private listen;
+    private extendViewport;
+    private observeNavigation;
+    destroy(): void;
+}
+
 /**
  * Where low events go. `flushKeepalive` is requested on `pagehide` teardown so lows batched after
  * the queue's own lifecycle flush still get out; operations wire it to the client's
@@ -434,49 +511,27 @@ declare function createLogger(options: CreateLoggerOptions): Logger;
  * (default true = historical behavior, can be disabled remotely).
  */
 interface LowEventSink {
+    reserveCaptureSeq?(): number;
     enqueueLowEvent(low: LowEvent): void;
     flushKeepalive(): void;
+    registerInputs?(fields: readonly HTMLInputElement[], flush: () => void): () => void;
+    beginCeremony?(initiator?: LowEventInitiator): {
+        settle(tailMs: number): void;
+        destroy(): void;
+    };
 }
 
-/**
- * Collects window-scoped "low" events around a WebAuthn ceremony: window focus/blur, document
- * visibility changes and visualviewport resize/scroll (batched). The listener set mirrors
- * connect-react's `installLowEventWindowListeners`; the event names match
- * {@link LowEventInputTracker}'s vocabulary.
- *
- * Unlike {@link LowEventInputTracker} (anchored to an input field, active for the owning
- * operation's lifetime), this tracker is armed only for the ceremony window: the owning operation
- * arms it on `ceremony.start()` and schedules disarming shortly after the ceremony settles, so
- * signals from the picker closing (focus return, dismiss animations) are still captured.
- *
- * Never triggers a flush — low events ride along on the queue's existing flush triggers.
- */
+/** Ceremony context lease on the shared observer. Never installs its own window listeners. */
 declare class LowEventWindowTracker {
     private logger;
     private sink;
-    private armed;
+    private lease?;
     private destroyed;
-    private disarmTimer;
-    private resizeBatcher;
-    private scrollBatcher;
-    private boundHandlers;
     constructor(logger: Logger, sink: LowEventSink);
-    /** Start listening. Idempotent; cancels a pending scheduled disarm (ceremony retry). */
-    arm(): void;
-    /**
-     * Disarm after `delayMs`. The tail keeps the listeners alive briefly after the ceremony settles:
-     * focus return and picker dismiss animations land after the WebAuthn promise resolves/rejects.
-     */
+    arm(initiator?: LowEventInitiator, conditional?: boolean): void;
     scheduleDisarm(delayMs: number): void;
-    /** Stop listening and flush the viewport batchers into the queue. Idempotent. */
     disarm(): void;
-    /** Disarm and refuse any further arming; for the owning operation's destroy(). */
     destroy(): void;
-    private cancelScheduledDisarm;
-    private pushLow;
-    private handleVisibilityChange;
-    private flushBatchers;
-    private wrapHandler;
 }
 
 /**
@@ -494,13 +549,34 @@ type StepHelper<TStart = {}, TFinished = {}, TTypedError = never> = {
 declare abstract class OperationFull {
     private tracker;
     private operationName;
+    private startReference?;
+    private captureSpecType?;
+    private captureSessionId?;
+    private readonly lowFlushers;
+    private readonly lowPrefillCapturers;
+    protected lowEventSink(sourceKind: LowEventSourceKind, fieldRole?: LowEventFieldRole): LowEventSink;
+    protected createLowCollector<T extends {
+        capturePrefill(newCapture?: boolean): void;
+    }>(create: () => T): T | undefined;
+    protected registerLowFlusher(flush: () => void): void;
+    private captureOptions;
     constructor(tracker: CorbadoTracker, operationName: SubflowType);
     /**
-     * Emits subflow_started. `data` supports the SubflowTrigger fields (`actor`,
-     * `explicitSpecType`, `ignoreAsInteraction`) plus free-form extras; see SubflowTrigger for when
-     * to set `ignoreAsInteraction` on programmatic starts.
+     * Emits an additional subflow_started; construction already emits the initial start.
+     * `data` supports SubflowTrigger fields (`actor`, `explicitSpecType`, `ignoreAsInteraction`)
+     * plus free-form extras; see SubflowTrigger for programmatic interaction suppression.
      */
     subflowStart(data: any, options?: StepOptions): void;
+    /**
+     * Capture values initialized by the application after constructing this operation, without
+     * dispatching DOM input events. Call immediately after initialization, before user editing.
+     * Each field/group emits at most one prefill per subflow start; values are never recorded.
+     */
+    capturePrefill(): void;
+    private captureInputPrefills;
+    /**
+     * @deprecated `subflow_trigger` will be removed in the next major version.
+     */
     trigger(data: SubflowTrigger, options?: StepOptions): void;
     customStep<TStart = {}, TFinished = {}>(stepName: string): StepHelper<TStart, TFinished>;
     protected subflowStepStarted(stepName: string, data: any, options?: StepOptions, ignoreAsInteraction?: boolean): void;
@@ -554,12 +630,16 @@ type PasskeyLoginPostResponseStart = {
      */
     assertionResponse?: string;
 };
+type PasskeyLoginOperationConfig = {
+    /** The classifier drops the attempt if no spec type arrives on any of its events — supply it here or on a step's start data as soon as known. */
+    explicitSpecType?: PasskeyOperationLoginExplicitSpecType;
+};
 declare class PasskeyLoginOperationFull extends OperationFull {
     readonly getOptions: StepHelper<PasskeyLoginGetOptionsStart, PasskeyLoginGetOptionsFinished>;
     readonly ceremony: StepHelper<PasskeyLoginCeremonyStart, PasskeyLoginCeremonyFinished>;
     readonly postResponse: StepHelper<PasskeyLoginPostResponseStart>;
     private lowEventTracker;
-    constructor(tracker: CorbadoTracker);
+    constructor(tracker: CorbadoTracker, config?: PasskeyLoginOperationConfig);
     /**
      * @deprecated `subflow_trigger` is not supported for passkey-login and will be removed in the
      * next major version.
@@ -576,13 +656,22 @@ type EmailOTPOperationPostResponseStart = {
     explicitSpecType?: EmailOTPOperationSpecType;
 };
 type EmailOTPOperationConfig = {
+    /** Email domain only, no full address. */
+    emailDomain?: string;
+    /** One real input, or an ordered group representing one OTP. */
+    inputHtmlField?: HTMLInputElement;
+    inputHtmlFields?: HTMLInputElement[];
     explicitSpecType?: EmailOTPOperationSpecType;
 };
 declare class EmailOtpOperationFull extends OperationFull {
+    private lowEventTracker?;
     readonly send: StepHelper<EmailOTPOperationSendOTPStart>;
     readonly postResponse: StepHelper<EmailOTPOperationPostResponseStart>;
     readonly resend: StepHelper;
     constructor(tracker: CorbadoTracker, config?: EmailOTPOperationConfig);
+    /** Rebind the ordered OTP group without starting a new subflow. An empty list detaches it. */
+    setInputFields(fields: readonly HTMLInputElement[]): void;
+    destroy(): void;
 }
 
 type SmsOTPOperationSpecType = "sms-otp-login" | "sms-otp-enrollment";
@@ -590,12 +679,19 @@ type SmsOTPOperationPostResponseStart = {
     explicitSpecType?: SmsOTPOperationSpecType;
 };
 type SmsOTPOperationConfig = {
+    /** One real input, or an ordered group representing one OTP. */
+    inputHtmlField?: HTMLInputElement;
+    inputHtmlFields?: HTMLInputElement[];
     explicitSpecType?: SmsOTPOperationSpecType;
 };
 declare class SmsOtpOperationFull extends OperationFull {
+    private lowEventTracker?;
     readonly postResponse: StepHelper<SmsOTPOperationPostResponseStart>;
     readonly resend: StepHelper;
     constructor(tracker: CorbadoTracker, config?: SmsOTPOperationConfig);
+    /** Rebind the ordered OTP group without starting a new subflow. An empty list detaches it. */
+    setInputFields(fields: readonly HTMLInputElement[]): void;
+    destroy(): void;
 }
 
 type EmailLinkOperationSpecType = "email-link-login" | "email-link-enrollment";
@@ -605,11 +701,15 @@ type EmailLinkOperationSendStart = {
 type EmailLinkOperationPostResponseStart = {
     explicitSpecType?: EmailLinkOperationSpecType;
 };
+type EmailLinkOperationConfig = {
+    /** The classifier drops the attempt if no spec type arrives on any of its events — supply it here or on a step's start data as soon as known. */
+    explicitSpecType?: EmailLinkOperationSpecType;
+};
 declare class EmailLinkOperationFull extends OperationFull {
     readonly send: StepHelper<EmailLinkOperationSendStart>;
     readonly postResponse: StepHelper<EmailLinkOperationPostResponseStart>;
     readonly resend: StepHelper;
-    constructor(tracker: CorbadoTracker);
+    constructor(tracker: CorbadoTracker, config?: EmailLinkOperationConfig);
 }
 
 /**
@@ -651,6 +751,7 @@ type PasskeyEnrollmentPostResponseStart = {
     attestationResponse?: string;
 };
 type PasskeyEnrollmentOperationConfig = {
+    /** The classifier drops the attempt if no spec type arrives on any of its events — supply it here or on a step's start data as soon as known. */
     explicitSpecType?: PasskeyOperationEnrollmentExplicitSpecType;
     /**
      * Marks the auto-emitted `subflow_started` as not user-driven (see SubflowTrigger.ignoreAsInteraction).
@@ -694,17 +795,13 @@ type PasswordLoginCUIGetOptionsFinished = {
 type PasswordLoginCUICeremonyStart = {
     explicitSpecType?: PasswordLoginCUISpecType;
 };
-type PasswordLoginAutoTrackConfig = {
-    explicitSpecType: "password-known-identifier";
-    /** The password input field. */
-    inputHtmlField: HTMLInputElement;
-} | {
-    explicitSpecType: "password-with-identifier";
-    /** The password input field. */
-    inputHtmlField: HTMLInputElement;
+type PasswordLoginExplicitSpecType = "password-known-identifier" | "password-with-identifier";
+type PasswordLoginConfig = {
+    explicitSpecType?: PasswordLoginExplicitSpecType;
+    /** The password input field. When set, low-event input tracking is attached to it. */
+    inputHtmlField?: HTMLInputElement;
     /**
-     * The identifier (e.g. email) input field. Accepted but not tracked yet — low-event
-     * tracking for a second field lands together with per-field attribution.
+     * The identifier (e.g. email) input field. Tracked separately from the password field.
      */
     identifierInputHtmlField?: HTMLInputElement;
 };
@@ -722,7 +819,8 @@ declare class PasswordLoginOperationFull extends OperationFull {
         postResponse: StepHelper;
     };
     private lowEventTracker?;
-    constructor(tracker: CorbadoTracker, autoTrackConfig?: PasswordLoginAutoTrackConfig);
+    private identifierLowEventTracker?;
+    constructor(tracker: CorbadoTracker, config?: PasswordLoginConfig);
     /**
      * @deprecated `subflow_trigger` is not supported for password-login and will be removed in the
      * next major version.
@@ -736,15 +834,17 @@ type PasswordEnrollmentTypedError = {
 };
 type PasswordEnrollmentTypedErrorCode = "requirements_not_fulfilled";
 type PasswordEnrollmentExplicitSpecType = "password-set" | "password-reset";
-type PasswordEnrollmentAutoTrackConfig = {
+type PasswordEnrollmentConfig = {
+    /** The classifier drops the attempt if no spec type arrives on any of its events — supply it here or on a step's start data as soon as known. */
     explicitSpecType?: PasswordEnrollmentExplicitSpecType;
+    /** The password input field. When set, low-event input tracking is attached to it. */
     inputHtmlField?: HTMLInputElement;
 };
 declare class PasswordEnrollmentOperationFull extends OperationFull {
     readonly clientValidation: StepHelper;
     readonly postResponse: StepHelper<{}, {}, PasswordEnrollmentTypedError>;
     private lowEventTracker?;
-    constructor(tracker: CorbadoTracker, autoTrackConfig?: PasswordEnrollmentAutoTrackConfig);
+    constructor(tracker: CorbadoTracker, config?: PasswordEnrollmentConfig);
     destroy(): void;
 }
 
@@ -768,16 +868,15 @@ type PasskeyLoginCUIGetOptionsFinished = {
     assertionOptions: string;
 };
 type OperationFullProvideIdentifierWithCUIConfig = {
+    /** When set, low event collection is enabled for the input field. */
     inputHtmlField?: HTMLInputElement;
     explicitSpecType?: ProvideIdentifierSpecType;
 };
-declare class OperationFullProvideIdentifierWithCUI {
-    private tracker;
+declare class OperationFullProvideIdentifierWithCUI extends OperationFull {
     private lowEventTracker?;
     readonly cui: {
         /**
-         * @deprecated `subflow_trigger` is not supported for the CUI part of provide-identifier and
-         * will be removed in the next major version.
+         * @deprecated `subflow_trigger` will be removed in the next major version.
          */
         trigger: (data: SubflowTrigger, options?: StepOptions) => void;
         getOptions: StepHelper<PasskeyLoginCUIGetOptionsStart, PasskeyLoginCUIGetOptionsFinished>;
@@ -786,32 +885,34 @@ declare class OperationFullProvideIdentifierWithCUI {
     };
     readonly provideIdentifier: {
         /**
-         * @deprecated `subflow_trigger` is not supported for provide-identifier and will be removed
-         * in the next major version.
+         * @deprecated `subflow_trigger` will be removed in the next major version.
          */
         trigger: (data: SubflowTrigger, options?: StepOptions) => void;
         clientValidation: StepHelper;
         postResponse: StepHelper<ProvideIdentifierPostResponseStart>;
     };
     constructor(tracker: CorbadoTracker, config?: OperationFullProvideIdentifierWithCUIConfig);
-    private createStep;
     destroy(): void;
 }
 
 type SocialLoginSpecType = "pre-identifier" | "post-identifier";
 type SocialLoginGetRedirectUrlStart = {
     provider?: SocialLoginProviderType;
-    explicitSpecType: SocialLoginSpecType;
+    explicitSpecType?: SocialLoginSpecType;
 };
 type SocialLoginGetRedirectUrlFinished = {};
 type SocialLoginExchangeCodeStart = {
     provider?: SocialLoginProviderType;
 };
 type SocialLoginExchangeCodeFinished = {};
+type SocialLoginOperationConfig = {
+    /** The classifier drops the attempt if no spec type arrives on any of its events — supply it here or on a step's start data as soon as known. */
+    explicitSpecType?: SocialLoginSpecType;
+};
 declare class SocialLoginOperationFull extends OperationFull {
     readonly getRedirectUrl: StepHelper<SocialLoginGetRedirectUrlStart, SocialLoginGetRedirectUrlFinished>;
     readonly exchangeCode: StepHelper<SocialLoginExchangeCodeStart, SocialLoginExchangeCodeFinished>;
-    constructor(tracker: CorbadoTracker);
+    constructor(tracker: CorbadoTracker, config?: SocialLoginOperationConfig);
 }
 
 type AppConfirmationOperationSpecType = "qr-code";
@@ -823,11 +924,14 @@ type AppConfirmationOperationCeremonyTypedError = {
 };
 type AppConfirmationOperationCeremonyTypedErrorCode = "declined" | "expired";
 type AppConfirmationOperationRetryReason = AppConfirmationOperationCeremonyTypedErrorCode | "technical-error" | "manual";
+type AppConfirmationOperationConfig = {
+    explicitSpecType?: AppConfirmationOperationSpecType;
+};
 declare class AppConfirmationOperationFull extends OperationFull {
     readonly ceremony: StepHelper<{}, {}, AppConfirmationOperationCeremonyTypedError>;
     readonly retry: StepHelper;
     readonly postResponse: StepHelper;
-    constructor(tracker: CorbadoTracker, explicitSpecType?: AppConfirmationOperationSpecType);
+    constructor(tracker: CorbadoTracker, config?: AppConfirmationOperationConfig);
 }
 
 /**
@@ -851,6 +955,7 @@ type ProvideDataOperationSpecType = "signup" | "login" | "recovery" | "enrollmen
 type ProvideDataOperationStart = {
     /** Stable name of the data field collected by this subflow, when known. */
     fieldName?: string;
+    /** The classifier drops the attempt if no spec type arrives on any of its events — supply it here or on a step's start data as soon as known. */
     explicitSpecType?: ProvideDataOperationSpecType;
 };
 type ProvideDataOperationConfig = ProvideDataOperationStart & {
@@ -940,6 +1045,9 @@ declare class CorbadoTracker {
     private telemetryReady;
     private readonly reportedTelemetryKeys;
     private pendingSelfTelemetry;
+    private windowObserver?;
+    /** @internal Shared passive page observation and per-operation context registration. */
+    getWindowObserver(): SharedWindowObserver;
     constructor(options: TrackerOptions);
     /**
      * Cache fresh server config as last-known so the next page load boots with it. When this load
@@ -1059,12 +1167,16 @@ declare class CorbadoTracker {
      * sessionStorage-backed and stable for the whole page lifetime.
      */
     private resolveEventTabId;
-    trackSubflowStarted(subflowType: SubflowType, data: Record<string, any>, options?: StepOptions): void;
+    trackSubflowStarted(subflowType: SubflowType, data: Record<string, any>, options?: StepOptions, eventId?: string): void;
     trackSubflowTrigger(subflowType: SubflowType, data: Record<string, any>, options?: StepOptions): void;
     trackSubflowStepStarted(subflowType: SubflowType, stepName: string, data: Record<string, any>, options?: StepOptions, ignoreAsInteraction?: boolean): void;
     trackSubflowStepFinished(subflowType: SubflowType, stepName: string, data: Record<string, any>, options?: StepOptions): void;
     trackSubflowStepError(subflowType: SubflowType, stepName: string, data: Record<string, any>, options?: StepOptions): void;
-    trackSubflowFinished(subflowType: SubflowType, data: Record<string, any>, options?: StepOptions): void;
+    /**
+     * @remarks
+     * Records an additional error occurrence against the subflow. Carries no outcome semantics —
+     * step errors are the intended channel; not part of a normal integration.
+     */
     trackSubflowError(subflowType: SubflowType, data: Record<string, any>, options?: StepOptions): void;
     /**
      * Error situations:
@@ -1073,7 +1185,12 @@ declare class CorbadoTracker {
      *
      * @internal
      */
-    track(name: AuthEventName, data: Record<string, any>, userReference?: UserReference, tags?: Record<string, string>, contexts?: Record<string, any>, explicitTimestamp?: number, experiments?: Record<string, string>): Promise<void>;
+    track(name: AuthEventName, data: Record<string, any>, userReference?: UserReference, tags?: Record<string, string>, contexts?: Record<string, any>, explicitTimestamp?: number, experiments?: Record<string, string>, capture?: {
+        id?: string;
+        subflowStartEventId?: string;
+        sessionId?: string;
+        initiator?: StepOptions["initiator"];
+    }): Promise<void>;
     /**
      * Track when an authentication flow (or flow selection screen) becomes visible.
      *
@@ -1121,10 +1238,12 @@ declare class CorbadoTracker {
      * Use this for outcomes you care about beyond auth, such as a completed purchase,
      * a started subscription, or a newsletter signup. Provide a stable `name` for the
      * conversion and (optionally) the `touchpoint` where it happened so it can be
-     * segmented in the same way as flows. If available, include `userId` and/or
-     * `identifier` to link the conversion to a user.
+     * segmented in the same way as flows. Record identity separately with `setUser()`
+     * while the relevant flow is still active.
+     *
+     * Legacy identity fields in `data` remain supported but are deprecated.
      *
-     * @param data - Conversion name, optional touchpoint, and optional user reference.
+     * @param data - Conversion name, optional touchpoint, and deprecated user reference fields.
      * @param tags - Optional key-value tags for filtering and segmentation.
      *
      * @example
@@ -1132,7 +1251,6 @@ declare class CorbadoTracker {
      * tracker.conversion({
      *   name: "purchase",
      *   touchpoint: "checkout",
-     *   userId: "usr_123",
      * });
      * ```
      */
@@ -1142,18 +1260,18 @@ declare class CorbadoTracker {
      *
      * @remarks
      * Fire this when the user has finished the target flow end-to-end, such as completed login,
-     * signup, or recovery. If available, include `userId` and/or `identifier` so the event is
-     * linked to a user reference.
+     * signup, or recovery. Record identity separately with `setUser()` while the flow
+     * is still active, before calling `flowFinished()`.
      *
-     * @param data - Finished flow name plus optional user reference fields.
+     * Legacy identity fields in `data` remain supported but are deprecated.
+     *
+     * @param data - Finished flow name, optional explicit outcome, and deprecated user reference fields.
      * @param tags - Optional key-value tags for filtering and segmentation.
      *
      * @example
      * ```typescript
      * tracker.flowFinished({
      *   flowName: "login",
-     *   userId: "usr_123",
-     *   identifier: "max@example.com",
      * });
      * ```
      */
@@ -1180,9 +1298,12 @@ declare class CorbadoTracker {
      * @remarks
      * Use this for automatic completions where no separate explicit finish action happens in the
      * current flow. Set `flowName` to the auto-finished flow and `finishedByFlowName` to the flow
-     * that caused it.
+     * that caused it. Record identity with `setUser()` while the intended flow is still
+     * current, before it is auto-finished.
+     *
+     * Legacy identity fields in `data` remain supported but are deprecated.
      *
-     * @param data - Auto-finished flow, finishing flow, and optional user reference fields.
+     * @param data - Auto-finished flow, finishing flow, and deprecated user reference fields.
      * @param tags - Optional key-value tags for filtering and segmentation.
      *
      * @example
@@ -1190,11 +1311,32 @@ declare class CorbadoTracker {
      * tracker.flowAutoFinished({
      *   flowName: "signup",
      *   finishedByFlowName: "login",
-     *   userId: "usr_123",
      * });
      * ```
      */
     flowAutoFinished(data: FlowAutoFinished, tags?: Record<string, string>, experiments?: Record<string, string>): void;
+    /**
+     * Record a newly known user reference for the current active flow.
+     *
+     * @remarks
+     * Emits one `flow_enriched` with `match: { flowType: "*", at: "during" }` and `expFol: true` in its data.
+     * Call only after the flow starts and before it finishes. The enrichment belongs
+     * to the current flow at emission time.
+     * Calling after `flowFinished()` cannot enrich that finished flow. If a parent or another
+     * flow is current then, the enrichment belongs to that flow instead.
+     * An empty reference does not clear identity. Cross-environment transaction IDs must be UUIDs;
+     * both environments must report the shared ID while their respective flows are active.
+     *
+     * @param user - User ID, identifier, and/or cross-environment transaction UUID.
+     *
+     * @example
+     * ```typescript
+     * tracker.flowStarted({ flowName: "login" });
+     * tracker.setUser({ userId: "usr_123", identifier: "max@example.com" });
+     * tracker.flowFinished({ flowName: "login" });
+     * ```
+     */
+    setUser(user: UserReference): void;
     /**
      * Track when you present authentication method choices to the user.
      *
@@ -1219,7 +1361,15 @@ declare class CorbadoTracker {
      */
     authMethodsDecisionStarted(data: AuthMethodDecisionStarted, tags?: Record<string, string>, experiments?: Record<string, string>, options?: Pick<StepOptions, "explicitTimestamp">): void;
     authMethodsDecisionFinished(data: AuthMethodDecisionFinished, tags?: Record<string, string>, experiments?: Record<string, string>): void;
+    /**
+     * @deprecated Use {@link CorbadoTracker.authMethodsDecisionStarted} instead (its `options`
+     * already accept free-form strings).
+     */
     authDecisionStarted(data: AuthDecisionStarted, tags?: Record<string, string>, experiments?: Record<string, string>): void;
+    /**
+     * @deprecated Use {@link CorbadoTracker.authMethodsDecisionFinished} instead (its `options`
+     * already accept free-form strings).
+     */
     authDecisionFinished(data: AuthDecisionFinished, tags?: Record<string, string>, experiments?: Record<string, string>): void;
     /**
      * Enqueue a "low" event (granular DOM/window/visualviewport/PWM signal) for the current session.
@@ -1230,7 +1380,7 @@ declare class CorbadoTracker {
      *
      * @internal
      */
-    enqueueLowEvent(low: LowEvent): void;
+    enqueueLowEvent(low: LowEvent, capturedSessionId?: string): void;
     /**
      * Record a diagnostic telemetry entry (a `level` + free-form `message`) for the current session.
      *
@@ -1278,17 +1428,17 @@ declare class CorbadoTracker {
      * @internal
      */
     lowEventFlushKeepalive(): void;
-    passkeyLoginFullOperation(): PasskeyLoginOperationFull;
+    passkeyLoginFullOperation(config?: PasskeyLoginOperationConfig): PasskeyLoginOperationFull;
     passkeyEnrollmentFullOperation(config?: PasskeyEnrollmentOperationConfig): PasskeyEnrollmentOperationFull;
-    passwordLoginFullOperation(autoTrackConfig?: PasswordLoginAutoTrackConfig): PasswordLoginOperationFull;
-    passwordEnrollmentFullOperation(autoTrackConfig?: PasswordEnrollmentAutoTrackConfig): PasswordEnrollmentOperationFull;
-    emailLinkOperationFull(): EmailLinkOperationFull;
+    passwordLoginFullOperation(autoTrackConfig?: PasswordLoginConfig): PasswordLoginOperationFull;
+    passwordEnrollmentFullOperation(autoTrackConfig?: PasswordEnrollmentConfig): PasswordEnrollmentOperationFull;
+    emailLinkOperationFull(config?: EmailLinkOperationConfig): EmailLinkOperationFull;
     emailOtpOperationFull(config?: EmailOTPOperationConfig): EmailOtpOperationFull;
     smsOtpOperationFull(config?: SmsOTPOperationConfig): SmsOtpOperationFull;
     provideIdentifierOperationFull(config?: OperationFullProvideIdentifierWithCUIConfig): OperationFullProvideIdentifierWithCUI;
     provideDataOperationFull(config?: ProvideDataOperationConfig): ProvideDataOperationFull;
-    socialLoginOperationFull(): SocialLoginOperationFull;
-    appConfirmationOperationFull(explicitSpecType?: AppConfirmationOperationSpecType): AppConfirmationOperationFull;
+    socialLoginOperationFull(config?: SocialLoginOperationConfig): SocialLoginOperationFull;
+    appConfirmationOperationFull(config?: AppConfirmationOperationConfig): AppConfirmationOperationFull;
     captchaOperationFull(config?: CaptchaOperationConfig): CaptchaOperationFull;
     /**
      * Flush any pending events and release all resources (timers, event listeners).
@@ -1341,6 +1491,7 @@ declare const SDK_NAME = "@corbado/observe";
 declare const SDK_VERSION: string;
 
 interface TransportMakeRequestResponse {
+    deliveryAccepted?: boolean;
     statusCode?: number;
     headers?: Record<string, string | null>;
     /** Parsed SDK reliability config, present only when the server returns it (HTTP 200). */
@@ -1501,7 +1652,7 @@ interface QueueOptions {
  * Pending events are held as {@link OutboxEntry} records. When `config.durableOutbox` is enabled they are
  * additionally persisted to a localStorage-backed {@link EventStore} and recovered on the next load.
  * Delivery removes an entry only on a 2xx response; retryable failures back off (honoring `Retry-After`)
- * up to `config.retry.maxAttempts`. Low events are best-effort and never persisted.
+ * up to `config.retry.maxAttempts`. Low events have a separately bounded outbox when durableLowOutbox is enabled.
  *
  * Flushing is timer-driven only (the flush interval); `batchSize` caps the events per request, and a
  * flush drains all due work in sequential capped batches, stopping at the first failed send.
@@ -1517,14 +1668,16 @@ declare class RequestQueue {
     private readonly storage?;
     private pending;
     private lowsQueue;
+    private lowPending;
+    private lowStore?;
     /**
-     * Diagnostic telemetry buffered for the current session. Best-effort and never persisted (like
-     * lows). Attached to the next outgoing batch for this session; a telemetry entry alone never arms
+     * Diagnostic telemetry buffered for the current session. Best-effort and never persisted. Attached to the next outgoing batch for this session; a telemetry entry alone never arms
      * the flush timer (it piggybacks), unless `config.flushOnTelemetry` escalates to an immediate flush.
      */
     private telemetryQueue;
     private timer;
     private isFlushing;
+    private flushingDone?;
     private destroyed;
     /**
      * True when something was enqueued (or recovered) since the last sync flush. visibilitychange,
@@ -1566,12 +1719,12 @@ declare class RequestQueue {
      * Error situations:
      *  - Any error while enqueueing or scheduling the flush timer: log "Failed to enqueue event"
      */
-    enqueue(event: Event): void;
+    enqueue(event: Event, capturedSessionId?: string): void;
     /**
      * Error situations:
      *  - Any error while enqueueing or scheduling the flush timer: log "Failed to enqueue low event"
      */
-    enqueueLow(low: LowEvent): void;
+    enqueueLow(low: LowEvent, capturedSessionId?: string): void;
     /**
      * Buffer a diagnostic telemetry entry for delivery with the next event batch.
      *
@@ -1619,6 +1772,10 @@ declare class RequestQueue {
     private attachBatchMeta;
     private getDuePending;
     private takeLows;
+    private validPendingLow;
+    private removeLowEntries;
+    private handleLowSendResult;
+    private deferLowEntries;
     private takeTelemetry;
     private shouldRequestConfig;
     /**
@@ -1754,7 +1911,7 @@ declare function loadCachedConfig(storage: StorageEngine): SdkReliabilityConfig
 declare function cacheConfig(storage: StorageEngine, config: SdkReliabilityConfig): void;
 
 /** A persisted, not-yet-acknowledged event awaiting delivery. */
-interface OutboxEntry {
+interface OutboxEntry<T = Event> {
     /** Event idempotency id; primary key of the entry. */
     id: string;
     /** Session id snapshot taken at enqueue time (so session rotation never relabels old entries). */
@@ -1764,7 +1921,7 @@ interface OutboxEntry {
     /** Number of completed send attempts so far. */
     attempts: number;
     /** The event payload. */
-    event: Event;
+    event: T;
 }
 /** localStorage key under which the durable outbox is persisted. */
 declare const OUTBOX_STORAGE_KEY = "cbo_outbox";
@@ -1790,7 +1947,7 @@ declare const DEFAULT_MAX_SERIALIZED_LENGTH: number;
  * behavior. Mutations never reject; failures are logged.
  * The store is size-capped; overflow evicts the oldest entries and logs the count.
  */
-declare class EventStore {
+declare class EventStore<T = Event> {
     private readonly storage;
     private readonly logger;
     private readonly maxEntries;
@@ -1801,6 +1958,7 @@ declare class EventStore {
      * and a shared key guarded by scoped locks would lose the cross-tab atomicity guarantee.
      */
     private readonly lockName;
+    private readonly storageKey;
     private entries;
     /** Malformed entries are dropped on every read; report only once per instance to avoid log spam. */
     private reportedMalformed;
@@ -1810,21 +1968,21 @@ declare class EventStore {
      * to: a project-scoped outbox key guarded by the shared lock would serialize unrelated trackers,
      * and a shared key guarded by scoped locks would lose the cross-tab atomicity guarantee.
      */
-    lockName?: string);
+    lockName?: string, storageKey?: string);
     private read;
     private mutate;
     /** Evict oldest entries until the serialized outbox fits {@link maxSerializedLength}. */
     private enforceSizeBudget;
     /** Append an entry. No-op if an entry with the same id already exists. */
-    add(entry: OutboxEntry): Promise<void>;
+    add(entry: OutboxEntry<T>): Promise<void>;
     /** Re-read from storage and return all entries (memory mirror refreshed). */
-    all(): OutboxEntry[];
+    all(): OutboxEntry<T>[];
     /** Entries whose `flushAfter` has elapsed, in insertion order. */
-    getDue(now: number): OutboxEntry[];
+    getDue(now: number): OutboxEntry<T>[];
     /** Remove entries by id (acknowledged or permanently dropped). */
     remove(ids: string[]): Promise<void>;
     /** Replace existing entries (matched by id) with updated copies, e.g. after bumping backoff. */
-    update(updated: OutboxEntry[]): Promise<void>;
+    update(updated: OutboxEntry<T>[]): Promise<void>;
     size(): number;
 }
 
@@ -1842,6 +2000,12 @@ declare function resetSession(): string | undefined;
  * could be established. See {@link CorbadoTracker.getSessionId}.
  */
 declare function getSessionId(): string | undefined;
+/**
+ * Record a user reference for the global tracker's current active flow.
+ * Call after the flow starts and before it finishes; matching has no grace period.
+ * See {@link CorbadoTracker.setUser}.
+ */
+declare function setUser(user: UserReference): void;
 declare function setExperiment(key: string, variant: string): void;
 declare function setExperiments(assignments: Record<string, string>): void;
 declare function clearExperiment(key: string): void;
@@ -1852,4 +2016,4 @@ declare function logInfo(message: string): void;
 declare function logError(message: string): void;
 declare function destroy(): Promise<void>;
 
-export { type AppConfirmationOperationCeremonyTypedError, AppConfirmationOperationFull, type AppConfirmationOperationRetryReason, type AppConfirmationOperationSpecType, type AppConfirmationOperationStart, type AuthDecisionFinished, type AuthDecisionStarted, AuthEventName, type AuthMethodDecisionFinished, type AuthMethodDecisionStarted, type AuthMethodType, type BaseEvent, CEREMONY_LOW_EVENT_TAIL_MS, CONFIG_BOUNDS, CONFIG_REQUEST_HEADER, CONFIG_STORAGE_KEY, type CaptchaOperationConfig, CaptchaOperationFull, type CaptchaOperationSpecType, type ClientCapabilities, type ClientEnvHandleMeta, type ClientEnvHandleMetaSource, type Conversion, CookieStorage, CorbadoTracker, type CreateLoggerOptions, type CustomEvent, DEFAULT_DEVICE_INFO_COLLECTOR_TIMEOUT_MS, DEFAULT_FLUSH_INTERVAL_MS, DEFAULT_MAX_ENTRIES, DEFAULT_MAX_SERIALIZED_LENGTH, DEFAULT_RELIABILITY_CONFIG, DEFAULT_SEQ_LOCK_TIMEOUT_MS, DEFAULT_SESSION_INACTIVITY_MS, type DeviceInfo, type DeviceInfoCollectionError, type DeviceInfoDataWeb, type DeviceType, EmailLinkOperationFull, type EmailLinkOperationPostResponseStart, type EmailLinkOperationSendStart, type EmailLinkOperationSpecType, type EmailOTPOperationConfig, type EmailOTPOperationPostResponseStart, type EmailOTPOperationSendOTPStart, type EmailOTPOperationSpecType, EmailOtpOperationFull, type Event, type EventBatch, type EventBatchMeta, type EventMeta, EventStore, type EventType, type FlowAutoFinished, type FlowDecided, type FlowFinished, type FlowReset, type FlowStarted, type FlowType, type FlushReason, type JavaScriptHighEntropy, LocalStorage, type Logger, type LowEvent, type MultiFlowReset, type MultiFlowStarted, NamespacedStorage, type NormalizedError, OUTBOX_LOCK_NAME, OUTBOX_STORAGE_KEY, type ObserveSdkConfigSnapshot, OperationFull, OperationFullProvideIdentifierWithCUI, type OperationFullProvideIdentifierWithCUIConfig, type OutboxEntry, type PasskeyEnrollmentCeremonyFinished, type PasskeyEnrollmentCeremonyStart, type PasskeyEnrollmentGetOptionsFinished, type PasskeyEnrollmentGetOptionsStart, type PasskeyEnrollmentOperationConfig, PasskeyEnrollmentOperationFull, type PasskeyEnrollmentPostResponseStart, type PasskeyLoginCUIGetOptionsFinished, type PasskeyLoginCUIGetOptionsStart, type PasskeyLoginCUISpecType, type PasskeyLoginCeremonyFinished, type PasskeyLoginCeremonyStart, type PasskeyLoginClientError, type PasskeyLoginFinish, type PasskeyLoginGetOptionsFinished, type PasskeyLoginGetOptionsStart, PasskeyLoginOperationFull, type PasskeyLoginPostResponseStart, type PasskeyLoginStartable, type PasskeyLoginSubmitted, type PasskeyOperationEnrollmentExplicitSpecType, type PasskeyOperationLoginExplicitSpecType, type PasswordEnrollmentAutoTrackConfig, PasswordEnrollmentOperationFull, type PasswordEnrollmentTypedError, type PasswordLoginAutoTrackConfig, type PasswordLoginCUICeremonyStart, type PasswordLoginCUIGetOptionsFinished, type PasswordLoginCUIGetOptionsStart, type PasswordLoginCUISpecType, type PasswordLoginCUITypedError, PasswordLoginOperationFull, type PasswordLoginTypedError, type PredefinedEvent, type ProvideDataOperationConfig, ProvideDataOperationFull, type ProvideDataOperationPostResponseStart, type ProvideDataOperationSpecType, type ProvideDataOperationStart, type ProvideIdentifierError, type ProvideIdentifierFinish, type ProvideIdentifierPostResponseStart, type ProvideIdentifierSpecType, type ProvideIdentifierStart, type QueueOptions, RequestQueue, SDK_NAME, SDK_VERSION, type SdkInfo, type SdkReliabilityConfig, type SdkRetryConfig, SessionStorage, type SmsOTPOperationConfig, type SmsOTPOperationPostResponseStart, type SmsOTPOperationSpecType, SmsOtpOperationFull, type SocialLoginExchangeCodeFinished, type SocialLoginExchangeCodeStart, type SocialLoginGetRedirectUrlFinished, type SocialLoginGetRedirectUrlStart, SocialLoginOperationFull, type SocialLoginProviderType, type SocialLoginSpecType, type StepHelper, type StepOptions, type StorageEngine, type SubflowTrigger, type SubflowType, type TelemetryEntry, type TelemetryLevel, type TelemetrySink, type TrackerOptions, type Transport, type TransportMakeRequestResponse, type TransportOptions, type UserReference, cacheConfig, clearExperiment, clearExperiments, createLogger, destroy, getExperiments, getSessionId, getTracker, init, loadCachedConfig, logError, logInfo, namespacedKey, parseReliabilityConfig, resetSession, setExperiment, setExperiments, telemetry };
+export { type AppConfirmationOperationCeremonyTypedError, type AppConfirmationOperationConfig, AppConfirmationOperationFull, type AppConfirmationOperationRetryReason, type AppConfirmationOperationSpecType, type AppConfirmationOperationStart, type AuthDecisionFinished, type AuthDecisionStarted, AuthEventName, type AuthMethodDecisionFinished, type AuthMethodDecisionStarted, type AuthMethodType, type BaseEvent, CEREMONY_LOW_EVENT_TAIL_MS, CONFIG_BOUNDS, CONFIG_REQUEST_HEADER, CONFIG_STORAGE_KEY, type CaptchaOperationConfig, CaptchaOperationFull, type CaptchaOperationSpecType, type ClientCapabilities, type ClientEnvHandleMeta, type ClientEnvHandleMetaSource, type Conversion, CookieStorage, CorbadoTracker, type CreateLoggerOptions, type CustomEvent, DEFAULT_DEVICE_INFO_COLLECTOR_TIMEOUT_MS, DEFAULT_FLUSH_INTERVAL_MS, DEFAULT_MAX_ENTRIES, DEFAULT_MAX_SERIALIZED_LENGTH, DEFAULT_RELIABILITY_CONFIG, DEFAULT_SEQ_LOCK_TIMEOUT_MS, DEFAULT_SESSION_INACTIVITY_MS, type DeviceInfo, type DeviceInfoCollectionError, type DeviceInfoDataWeb, type DeviceType, type EmailLinkOperationConfig, EmailLinkOperationFull, type EmailLinkOperationPostResponseStart, type EmailLinkOperationSendStart, type EmailLinkOperationSpecType, type EmailOTPOperationConfig, type EmailOTPOperationPostResponseStart, type EmailOTPOperationSendOTPStart, type EmailOTPOperationSpecType, EmailOtpOperationFull, type Event, type EventBatch, type EventBatchMeta, type EventMeta, EventStore, type EventType, type FlowAutoFinished, type FlowDecided, type FlowFinished, type FlowReset, type FlowStarted, type FlowType, type FlushReason, type JavaScriptHighEntropy, LocalStorage, type Logger, type LowEvent, type LowEventFieldRole, type LowEventInitiator, type LowEventInputEffect, type LowEventSourceKind, type MultiFlowReset, type MultiFlowStarted, NamespacedStorage, type NormalizedError, OUTBOX_LOCK_NAME, OUTBOX_STORAGE_KEY, type ObserveSdkConfigSnapshot, OperationFull, OperationFullProvideIdentifierWithCUI, type OperationFullProvideIdentifierWithCUIConfig, type OutboxEntry, type PasskeyEnrollmentCeremonyFinished, type PasskeyEnrollmentCeremonyStart, type PasskeyEnrollmentGetOptionsFinished, type PasskeyEnrollmentGetOptionsStart, type PasskeyEnrollmentOperationConfig, PasskeyEnrollmentOperationFull, type PasskeyEnrollmentPostResponseStart, type PasskeyLoginCUIGetOptionsFinished, type PasskeyLoginCUIGetOptionsStart, type PasskeyLoginCUISpecType, type PasskeyLoginCeremonyFinished, type PasskeyLoginCeremonyStart, type PasskeyLoginClientError, type PasskeyLoginFinish, type PasskeyLoginGetOptionsFinished, type PasskeyLoginGetOptionsStart, type PasskeyLoginOperationConfig, PasskeyLoginOperationFull, type PasskeyLoginPostResponseStart, type PasskeyLoginStartable, type PasskeyLoginSubmitted, type PasskeyOperationEnrollmentExplicitSpecType, type PasskeyOperationLoginExplicitSpecType, type PasswordEnrollmentConfig, PasswordEnrollmentOperationFull, type PasswordEnrollmentTypedError, type PasswordLoginCUICeremonyStart, type PasswordLoginCUIGetOptionsFinished, type PasswordLoginCUIGetOptionsStart, type PasswordLoginCUISpecType, type PasswordLoginCUITypedError, type PasswordLoginConfig, type PasswordLoginExplicitSpecType, PasswordLoginOperationFull, type PasswordLoginTypedError, type PredefinedEvent, type ProvideDataOperationConfig, ProvideDataOperationFull, type ProvideDataOperationPostResponseStart, type ProvideDataOperationSpecType, type ProvideDataOperationStart, type ProvideIdentifierError, type ProvideIdentifierFinish, type ProvideIdentifierPostResponseStart, type ProvideIdentifierSpecType, type ProvideIdentifierStart, type QueueOptions, RequestQueue, SDK_NAME, SDK_VERSION, type SdkInfo, type SdkReliabilityConfig, type SdkRetryConfig, SessionStorage, type SmsOTPOperationConfig, type SmsOTPOperationPostResponseStart, type SmsOTPOperationSpecType, SmsOtpOperationFull, type SocialLoginExchangeCodeFinished, type SocialLoginExchangeCodeStart, type SocialLoginGetRedirectUrlFinished, type SocialLoginGetRedirectUrlStart, type SocialLoginOperationConfig, SocialLoginOperationFull, type SocialLoginProviderType, type SocialLoginSpecType, type StepHelper, type StepOptions, type StorageEngine, type SubflowTrigger, type SubflowType, type TelemetryEntry, type TelemetryLevel, type TelemetrySink, type TrackerOptions, type Transport, type TransportMakeRequestResponse, type TransportOptions, type UserReference, cacheConfig, clearExperiment, clearExperiments, createLogger, destroy, getExperiments, getSessionId, getTracker, init, loadCachedConfig, logError, logInfo, namespacedKey, parseReliabilityConfig, resetSession, setExperiment, setExperiments, setUser, telemetry };