@corbado/observe 0.0.0-next.local.1772615508

package/dist/index.d.ts

@@ -0,0 +1,1068 @@
+interface User {
+    id?: string;
+    email?: string;
+    username?: string;
+    name?: string;
+    [key: string]: unknown;
+}
+interface SdkInfo {
+    name: string;
+    version: string;
+}
+type EventType = "predefined" | "custom" | "error" | "identify";
+type LoginMethodType = "identifier-email" | "passkey" | "passkey-conditional-ui" | "password" | "email-otp" | "email-link" | "phone-otp" | "switch-method" | "reset-flow" | "social-google" | "social-apple" | "social-facebook" | "social-other";
+type SocialLoginProviderType = "google" | "apple" | "facebook" | "github" | "microsoft" | "other";
+declare enum AuthEventName {
+    LoginVisible = "login_visible",
+    LoginReset = "login_reset",
+    LoginMethodsDecision = "login_method_decision_offered",
+    AuthDecisionVisible = "auth_decision_visible",
+    AuthDecisionFinished = "auth_decision_finished",
+    ProvideIdentifierStarted = "provide_identifier_started",
+    ProvideIdentifierSubmitted = "provide_identifier_submitted",
+    ProvideIdentifierFinished = "provide_identifier_finished",
+    ProvideIdentifierError = "provide_identifier_error",
+    PasswordLoginStartable = "password_login_startable",
+    PasswordLoginStarted = "password_login_started",
+    PasswordLoginSubmitted = "password_login_submitted",
+    PasswordLoginFinished = "password_login_finished",
+    PasswordLoginError = "password_login_error",
+    PasswordLoginForgotPasswordClicked = "password_login_forgot_password_clicked",
+    PasskeyLoginStartable = "passkey_login_startable",
+    PasskeyLoginStarted = "passkey_login_started",
+    PasskeyLoginSubmitted = "passkey_login_submitted",
+    PasskeyLoginFinished = "passkey_login_finished",
+    PasskeyLoginError = "passkey_login_error",
+    CUILoginStartable = "cui_login_startable",
+    CUILoginStarted = "cui_login_started",
+    CUILoginSubmitted = "cui_login_submitted",
+    CUILoginFinished = "cui_login_finished",
+    CUILoginError = "cui_login_error",
+    SocialLoginStarted = "social_login_started",
+    SocialLoginFinished = "social_login_finished",
+    SocialLoginError = "social_login_error",
+    LoginFinish = "login_finish",
+    SignupVisible = "signup_visible",
+    SignupFinish = "signup_finish",
+    SecurityEnrollmentStarted = "security_enrollment_started",
+    SecurityEnrollmentFinished = "security_enrollment_finished",
+    PasskeyEnrollmentStartable = "passkey_enrollment_startable",
+    PasskeyEnrollmentStarted = "passkey_enrollment_started",
+    PasskeyEnrollmentSubmitted = "passkey_enrollment_submitted",
+    PasskeyEnrollmentFinished = "passkey_enrollment_finished",
+    PasskeyEnrollmentSkipped = "passkey_enrollment_skipped",
+    PasskeyEnrollmentError = "passkey_enrollment_error",
+    AccountRecoveryStarted = "account_recovery_started",
+    AccountRecoveryFinished = "account_recovery_finished",
+    EmailLinkStartable = "email_link_startable",
+    EmailLinkSubmitted = "email_link_submitted",
+    EmailLinkFinished = "email_link_finished",
+    EmailLinkError = "email_link_error",
+    EmailOTPStartable = "email_otp_startable",
+    EmailOTPStarted = "email_otp_started",
+    EmailOTPSubmitted = "email_otp_submitted",
+    EmailOTPFinished = "email_otp_finished",
+    EmailOTPError = "email_otp_error",
+    EmailOTPResent = "email_otp_resent",
+    SetPasswordStartable = "set_password_startable",
+    SetPasswordStarted = "set_password_started",
+    SetPasswordSubmitted = "set_password_submitted",
+    SetPasswordFinished = "set_password_finished",
+    SetPasswordError = "set_password_error"
+}
+interface BaseEvent {
+    timestamp: number;
+    seq: number;
+    type: EventType;
+    user?: UserReference;
+    contexts?: Record<string, unknown>;
+    tags?: Record<string, string>;
+    deviceInfo?: DeviceInfo;
+}
+type WithSubFlowId<T> = T & {
+    subFlowId?: string;
+};
+type UserReference = {
+    userId?: string;
+    identifier?: string;
+    crossEnvironmentTransactionID?: string;
+};
+/**
+ * Serializable error shape produced by {@link normalizeError}.
+ * All error event payloads use this instead of raw Error objects.
+ */
+type NormalizedError = {
+    name?: string;
+    message: string;
+};
+interface LoginVisible {
+    /**
+     * Where the login form is shown (e.g. `"account"`, `"checkout"`).
+     */
+    touchpoint?: string;
+    identifierPrefillingExisted?: boolean;
+}
+type IdentifierProvided = UserReference & {
+    availableMethods?: string[];
+    preferredMethod?: string | null;
+};
+type ProvideIdentifierStart = {};
+type ProvideIdentifierError = UserReference & {
+    errorCode?: string;
+    error?: any;
+};
+type ProvideIdentifierFinish = UserReference & {
+    identifierPrefillingCreated?: boolean;
+};
+interface PasswordLoginStartable {
+    explicitSpecType?: "pre-identifier" | "post-identifier";
+}
+interface PasswordLoginStarted {
+    explicitSpecType?: "pre-identifier" | "post-identifier";
+}
+type PasswordLoginFinish = {};
+type LoginStepPasswordErrorCode = 'invalid_password' | 'unknown';
+type PasswordLoginError = {
+    errorCode?: LoginStepPasswordErrorCode;
+    error?: any;
+};
+type PasskeyLoginClientError = {
+    error: any;
+};
+type PasskeyLoginStart = {
+    explicitSpecType: "passkey-cui" | "passkey-identifier" | "passkey-button";
+    conditional: boolean;
+} & PasskeyLoginStartable;
+type PasskeyLoginStartable = {
+    assertionOptions: string;
+};
+type PasskeyLoginSubmitted = {
+    assertionResponse: string;
+};
+type PasskeyLoginFinish = UserReference & {};
+type SocialLoginStart = {
+    explicitSpecType: "pre-identifier" | "post-identifier";
+    provider: SocialLoginProviderType;
+};
+type SocialLoginFinish = UserReference & {
+    provider: SocialLoginProviderType;
+};
+type SocialLoginError = UserReference & {
+    errorCode: string;
+};
+type LoginReset = {};
+type LoginFinish = UserReference & {};
+type LoginMethodDecision = {
+    decisionName: string;
+    availableMethods: LoginMethodType[];
+    explicitDecisionValue?: string;
+};
+type AuthDecisionVisible = {
+    decisionName: string;
+    options: string[];
+};
+type AuthDecisionFinished = {
+    decisionName: string;
+    options: string[];
+    explicitDecisionValue?: string;
+};
+type SignupVisible = {
+    touchpoint?: string;
+};
+type SignupFinish = UserReference & {};
+type PasskeyEnrollmentStartable = {};
+type PasskeyEnrollmentStarted = {
+    conditional: boolean;
+    auto: boolean;
+    attestationOptions: string;
+};
+type PasskeyEnrollmentSubmitted = {
+    conditional: boolean;
+    auto: boolean;
+    attestationResponse: string;
+};
+type PasskeyEnrollmentFinished = {};
+type PasskeyEnrollmentError = {
+    errorCode?: string;
+    error?: unknown;
+};
+interface PredefinedEvent extends BaseEvent {
+    type: "predefined";
+    name: string;
+    data: Record<string, unknown>;
+}
+interface CustomEvent extends BaseEvent {
+    type: "custom";
+    name: string;
+    data?: Record<string, unknown>;
+}
+type Event = PredefinedEvent | CustomEvent;
+interface EventBatch {
+    sessionId: string;
+    events: Event[];
+    sdk: SdkInfo;
+}
+type DeviceType = "web" | "app" | "other";
+interface DeviceInfo {
+    type: DeviceType;
+    clientEnvHandle: string;
+    clientEnvHandleMeta: ClientEnvHandleMeta;
+    data: DeviceInfoDataWeb;
+}
+interface DeviceInfoDataWeb {
+    bluetoothAvailable?: boolean;
+    conditionalMediationAvailable?: boolean;
+    userVerifyingPlatformAuthenticatorAvailable?: boolean;
+    clientCapabilities?: ClientCapabilities;
+    javaScriptHighEntropy?: JavaScriptHighEntropy;
+    privateMode?: boolean;
+    webdriver?: boolean;
+}
+type ClientCapabilities = Record<string, string>;
+type JavaScriptHighEntropy = {
+    platform?: string;
+    mobile?: boolean;
+    platformVersion?: string;
+};
+type ClientEnvHandleMeta = {
+    timestamp: number;
+    source: ClientEnvHandleMetaSource;
+};
+type ClientEnvHandleMetaSource = "localstorage" | "cookie" | "native";
+type SecurityEnrollmentStarted = {
+    touchpoint: string;
+} & UserReference;
+type AccountRecoveryStarted = {
+    touchpoint: string;
+};
+type EmailOTPStartable = {};
+type EmailOTPStarted = {};
+type EmailOTPSubmitted = {};
+type EmailOTPFinished = {};
+type EmailOTPError = {
+    errorCode: string;
+};
+type EmailOTPResent = {};
+type EmailLinkStartable = {
+    crossEnvironmentTransactionID?: string;
+} & UserReference;
+type EmailLinkSubmitted = {
+    crossEnvironmentTransactionID?: string;
+};
+type EmailLinkFinished = {} & UserReference;
+type EmailLinkError = {
+    errorCode: string;
+};
+type SetPasswordStartable = {};
+type SetPasswordStarted = {};
+type SetPasswordSubmitted = {};
+type SetPasswordFinished = {};
+type SetPasswordError = {
+    errorCode: string;
+    origin: "client" | "server";
+};
+
+declare class PasskeyOperationLogin {
+    private tracker;
+    constructor(tracker: CorbadoTracker, data: PasskeyLoginStart, tags?: Record<string, string>, contexts?: Record<string, any>);
+    started(data: PasskeyLoginStart, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    submitted(data: PasskeyLoginSubmitted, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    finished(data: PasskeyLoginFinish, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    clientError(data: PasskeyLoginClientError, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    serverErrorUnknown(error?: any, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+}
+
+declare class PasskeyOperationEnrollment {
+    private tracker;
+    constructor(tracker: CorbadoTracker, data: PasskeyEnrollmentStartable, tags?: Record<string, string>, contexts?: Record<string, any>);
+    startable(data: PasskeyEnrollmentStartable, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    started(data: PasskeyEnrollmentStarted, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    submitted(data: PasskeyEnrollmentSubmitted, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    finished(data: PasskeyEnrollmentFinished, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    skipped(data: {}, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    clientError(data: PasskeyEnrollmentError, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    serverErrorUnknown(error?: any, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+}
+
+declare class ProvideIdentifierOperation {
+    private tracker;
+    private patternDetector?;
+    constructor(tracker: CorbadoTracker, inputHtmlField?: HTMLInputElement);
+    destroy(): void;
+    identifierStarted(data: ProvideIdentifierStart, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    identifierSubmitted(data: {}, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    identifierFinished(data: ProvideIdentifierFinish, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    identifierError(data: ProvideIdentifierError, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    conditionalUIStartable(data: PasskeyLoginStartable, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    conditionalUISubmitted(data: PasskeyLoginSubmitted, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    conditionalUIFinished(data: PasskeyLoginFinish, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    conditionalUIClientError(data: PasskeyLoginClientError, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    conditionalUIServerErrorConditionalUICredentialDeleted(tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    conditionalUIServerErrorUnknown(error?: any, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+}
+
+declare class PasswordOperationLogin {
+    private tracker;
+    private patternDetector?;
+    constructor(tracker: CorbadoTracker, inputHtmlField?: HTMLInputElement);
+    startable(data: PasswordLoginStartable, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    started(data: PasswordLoginStarted, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    submitted(data: {}, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    finished(data: PasswordLoginFinish, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    error(data: PasswordLoginError, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    /**
+     * Fire when the user clicks on the "Forgot password" link during the password login flow.
+     */
+    forgotPasswordClicked(data: {}, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    destroy(): void;
+}
+
+declare class SocialOperationLogin {
+    private tracker;
+    constructor(tracker: CorbadoTracker);
+    started(data: SocialLoginStart, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    finished(data: SocialLoginFinish, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    error(data: SocialLoginError, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+}
+
+declare class EmailOTPOperation {
+    private tracker;
+    constructor(tracker: CorbadoTracker);
+    startable(data?: EmailOTPStartable, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    started(data?: EmailOTPStarted, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    submitted(data?: EmailOTPSubmitted, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    finished(data?: EmailOTPFinished, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    error(data: EmailOTPError, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    resent(data?: EmailOTPResent, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+}
+
+declare class EmailLinkOperation {
+    private tracker;
+    constructor(tracker: CorbadoTracker);
+    /**
+     * Fire when the email containing the link has been sent to the user.
+     */
+    startable(data?: EmailLinkStartable, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    /**
+     * Fire when the link has been opened and right before the verification process starts.
+     */
+    submitted(data?: EmailLinkSubmitted, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    /**
+     * Fire when the verification process has been completed successfully.
+     */
+    finished(data?: EmailLinkFinished, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    /**
+     * Fire when an error occurs during the verification process.
+     */
+    error(data: EmailLinkError, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+}
+
+declare class SetPasswordOperation {
+    private tracker;
+    private patternDetector?;
+    constructor(tracker: CorbadoTracker, inputHtmlField?: HTMLInputElement);
+    startable(data?: SetPasswordStartable, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    started(data?: SetPasswordStarted, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    submitted(data?: SetPasswordSubmitted, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    finished(data?: SetPasswordFinished, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    error(data: SetPasswordError, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    destroy(): void;
+}
+
+interface TrackerOptions {
+    projectId: string;
+    apiBaseUrl: string;
+    apiEventPath?: string;
+    storage?: "cookie" | "local";
+    debug?: boolean;
+    deviceInfoDebounceTime?: number;
+    defaultTags?: Record<string, string>;
+    applicationId?: string;
+}
+declare class CorbadoTracker {
+    private options;
+    private queue;
+    private sessionId;
+    private storage;
+    private sessionStorage;
+    private deviceInfoCollector;
+    private deviceInfoDebounceTime;
+    private deviceInfoTransmittedLastTime;
+    private seq;
+    constructor(options: TrackerOptions);
+    private applicationTag;
+    private debugMessage;
+    private isTrackingBlocked;
+    private getSessionId;
+    private updateDeviceDebounced;
+    /** @internal */
+    track(name: AuthEventName, data: Record<string, any>, userReference?: UserReference, tags?: Record<string, string>, contexts?: Record<string, any>, explicitTimestamp?: number): Promise<void>;
+    /**
+     * Track when the login UI becomes visible to the user.
+     *
+     * @remarks
+     * Trigger this event when your login form or login page is rendered and visible.
+     * Use the `touchpoint` field to distinguish where the login appears
+     * (e.g. a dedicated login page vs. an inline checkout login).
+     *
+     * @param data - Event payload.
+     * @param tags - Optional key-value tags for filtering and segmentation.
+     *
+     * @example
+     * ```typescript
+     * tracker.loginVisible({ touchpoint: "account" });
+     * ```
+     */
+    loginVisible(data: LoginVisible, tags?: Record<string, string>): void;
+    /**
+     * Create a trackable identifier-provision operation without immediately firing an event.
+     *
+     * @remarks
+     * Returns a {@link ProvideIdentifierOperation} that you can drive through
+     * `identifierStarted` → `identifierSubmitted` → `identifierFinished` / `identifierError`.
+     * Pass an `inputHtmlField` to auto-instrument keystroke and paste detection on the identifier input.
+     *
+     * @param inputHtmlField - Optional HTML input element to instrument for interaction detection.
+     * @returns A {@link ProvideIdentifierOperation} instance.
+     *
+     * @example
+     * ```typescript
+     * const op = tracker.provideIdentifierStartable(document.getElementById("email") as HTMLInputElement);
+     * op.identifierStarted();
+     * ```
+     */
+    provideIdentifierStartable(inputHtmlField?: HTMLInputElement): ProvideIdentifierOperation;
+    /**
+     * Track the start of the identifier-provision step and return the operation handle.
+     *
+     * @remarks
+     * Call this when the user begins entering their identifier (email, phone, username).
+     * The returned {@link ProvideIdentifierOperation} lets you continue tracking through
+     * submission, completion, or error.
+     *
+     * @param data - Event payload (currently empty, reserved for future fields).
+     * @param inputHtmlField - Optional HTML input element to instrument for interaction detection.
+     * @param tags - Optional key-value tags for filtering and segmentation.
+     * @param contexts - Optional contextual metadata attached to the event.
+     * @returns A {@link ProvideIdentifierOperation} instance.
+     *
+     * @example
+     * ```typescript
+     * const op = tracker.provideIdentifierStarted({}, emailInput);
+     * ```
+     */
+    provideIdentifierStarted(data?: ProvideIdentifierStart, inputHtmlField?: HTMLInputElement, tags?: Record<string, string>, contexts?: Record<string, any>): ProvideIdentifierOperation;
+    /**
+     * Track when the user submits their identifier.
+     *
+     * @remarks
+     * Fire this event after the user confirms their identifier (e.g. clicks "Continue"
+     * or presses Enter). This sits between the started and finished/error events.
+     *
+     * @param data - Event payload (currently empty, reserved for future fields).
+     * @param tags - Optional key-value tags for filtering and segmentation.
+     * @param contexts - Optional contextual metadata attached to the event.
+     *
+     * @example
+     * ```typescript
+     * tracker.provideIdentifierSubmitted({});
+     * ```
+     */
+    provideIdentifierSubmitted(data: {}, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    /**
+     * Track when identifier provision completes successfully.
+     *
+     * @remarks
+     * Fire this after the backend has validated the identifier and returned
+     * the available authentication methods. Include `availableMethods` and
+     * `preferredMethod` so downstream analytics can evaluate method selection.
+     *
+     * @param data - Event payload containing the user reference and available methods.
+     * @param tags - Optional key-value tags for filtering and segmentation.
+     * @param contexts - Optional contextual metadata attached to the event.
+     *
+     * @example
+     * ```typescript
+     * tracker.provideIdentifierFinished({
+     *   identifier: "user@example.com",
+     *   availableMethods: ["passkey", "password"],
+     *   preferredMethod: "passkey",
+     * });
+     * ```
+     */
+    provideIdentifierFinished(data: ProvideIdentifierFinish, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    /**
+     * Track when identifier provision fails.
+     *
+     * @remarks
+     * Fire this when the identifier lookup or validation returns an error
+     * (e.g. unknown user, rate limit, network failure).
+     *
+     * @param data - Event payload containing the user reference and error details.
+     * @param tags - Optional key-value tags for filtering and segmentation.
+     * @param contexts - Optional contextual metadata attached to the event.
+     *
+     * @example
+     * ```typescript
+     * tracker.provideIdentifierError({
+     *   identifier: "user@example.com",
+     *   error: "user_not_found",
+     * });
+     * ```
+     */
+    provideIdentifierError(data: ProvideIdentifierError, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    /**
+     * Track when the login flow is reset.
+     *
+     * @remarks
+     * Fire this event when the user navigates back to the beginning of the login flow,
+     * for example by clicking a "Back" button or choosing "Try another method".
+     * This signals that the current authentication attempt was abandoned.
+     *
+     * @param data - Event payload (currently empty, reserved for future fields).
+     * @param tags - Optional key-value tags for filtering and segmentation.
+     * @param contexts - Optional contextual metadata attached to the event.
+     *
+     * @example
+     * ```typescript
+     * tracker.loginReset();
+     * ```
+     */
+    loginReset(data?: LoginReset, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    /**
+     * Create a trackable password-login operation and mark it as startable.
+     *
+     * @remarks
+     * Returns a {@link PasswordOperationLogin} that you can drive through the
+     * `started` → `submitted` → `finished` / `error` lifecycle.
+     * Pass an `inputHtmlField` to auto-instrument the password input for
+     * interaction detection (e.g. paste, password-manager usage).
+     *
+     * @param inputHtmlField - Optional HTML input element to instrument.
+     * @param data
+     * @param tags - Optional key-value tags for filtering and segmentation.
+     * @param contexts - Optional contextual metadata attached to the event.
+     * @returns A {@link PasswordOperationLogin} instance.
+     *
+     * @example
+     * ```typescript
+     * const op = tracker.passwordLoginStartable(document.getElementById("password") as HTMLInputElement);
+     * ```
+     */
+    passwordLoginStartable(inputHtmlField?: HTMLInputElement, data?: PasswordLoginStartable, tags?: Record<string, string>, contexts?: Record<string, any>): PasswordOperationLogin;
+    /**
+     * Track the start of a password login attempt.
+     *
+     * @remarks
+     * Fire this when the user begins entering their password.
+     * Use the payload fields to record whether a password manager
+     * was detected or the keyboard was used for input.
+     *
+     * @param data - Event payload with optional interaction metadata.
+     * @param tags - Optional key-value tags for filtering and segmentation.
+     * @param contexts - Optional contextual metadata attached to the event.
+     * @returns A {@link PasswordOperationLogin} instance.
+     *
+     * @example
+     * ```typescript
+     * const op = tracker.passwordLoginStarted({ passwordManagerUsed: true });
+     * ```
+     */
+    passwordLoginStarted(data?: PasswordLoginStarted, tags?: Record<string, string>, contexts?: Record<string, any>): PasswordOperationLogin;
+    /**
+     * Track when the user submits their password.
+     *
+     * @remarks
+     * Fire this after the user confirms their password entry (e.g. clicks
+     * "Sign in" or presses Enter). This sits between the started and
+     * finished/error events.
+     *
+     * @param data - Event payload (currently empty, reserved for future fields).
+     * @param tags - Optional key-value tags for filtering and segmentation.
+     * @param contexts - Optional contextual metadata attached to the event.
+     *
+     * @example
+     * ```typescript
+     * tracker.passwordLoginSubmitted({});
+     * ```
+     */
+    passwordLoginSubmitted(data: {}, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    /**
+     * Track when a password login completes successfully.
+     *
+     * @remarks
+     * Fire this after the backend has verified the password and the user
+     * is authenticated.
+     *
+     * @param data - Event payload (currently empty, reserved for future fields).
+     * @param tags - Optional key-value tags for filtering and segmentation.
+     * @param contexts - Optional contextual metadata attached to the event.
+     *
+     * @example
+     * ```typescript
+     * tracker.passwordLoginFinished({});
+     * ```
+     */
+    passwordLoginFinished(data: PasswordLoginFinish, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    /**
+     * Track when a password login attempt fails.
+     *
+     * @remarks
+     * Fire this when password verification fails (e.g. invalid password,
+     * account locked, server error).
+     *
+     * @param data - Event payload (currently empty, reserved for future fields).
+     * @param tags - Optional key-value tags for filtering and segmentation.
+     * @param contexts - Optional contextual metadata attached to the event.
+     *
+     * @example
+     * ```typescript
+     * tracker.passwordLoginError({});
+     * ```
+     */
+    passwordLoginError(data: PasswordLoginError, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    /**
+     * Track the start of a passkey (WebAuthn) login and return the operation handle.
+     *
+     * @remarks
+     * Fire this when a passkey authentication ceremony begins.
+     * Set `conditional` to `true` for Conditional UI (autofill) flows, or `false`
+     * for an explicit "Sign in with passkey" button click.
+     * The returned {@link PasskeyOperationLogin} manages the remaining lifecycle events
+     * (submitted, finished, error) automatically.
+     *
+     * @param data - Event payload including the `conditional` flag.
+     * @param tags - Optional key-value tags for filtering and segmentation.
+     * @param contexts - Optional contextual metadata attached to the event.
+     * @returns A {@link PasskeyOperationLogin} instance.
+     *
+     * @example
+     * ```typescript
+     * const op = tracker.passkeyLoginStart({ conditional: false });
+     * ```
+     */
+    passkeyLoginStart(data: PasskeyLoginStart, tags?: Record<string, string>, contexts?: Record<string, any>): PasskeyOperationLogin;
+    /**
+     * Track the start of a social login (OAuth / OpenID Connect) flow.
+     *
+     * @remarks
+     * Fire this when the user initiates a social login (e.g. clicks "Sign in with Google").
+     * Specify the `provider` (e.g. `"google"`, `"apple"`) so analytics can break down
+     * conversion by provider.
+     *
+     * @param data - Event payload containing the social `provider` name.
+     * @param tags - Optional key-value tags for filtering and segmentation.
+     * @param contexts - Optional contextual metadata attached to the event.
+     * @returns A {@link SocialOperationLogin} instance.
+     *
+     * @example
+     * ```typescript
+     * const op = tracker.socialLoginStart({ provider: "google" });
+     * ```
+     */
+    socialLoginStart(data: SocialLoginStart, tags?: Record<string, string>, contexts?: Record<string, any>): SocialOperationLogin;
+    /**
+     * Track when a social login attempt fails.
+     *
+     * @remarks
+     * Fire this when the OAuth callback returns an error or when token
+     * exchange with the social provider fails.
+     *
+     * @param data - Event payload containing the user reference and `errorCode`.
+     * @param tags - Optional key-value tags for filtering and segmentation.
+     * @param contexts - Optional contextual metadata attached to the event.
+     *
+     * @example
+     * ```typescript
+     * tracker.socialLoginError({ errorCode: "OAuthAccountNotLinked" });
+     * ```
+     */
+    socialLoginError(data: SocialLoginError, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    /**
+     * Track when a social login completes successfully.
+     *
+     * @remarks
+     * Fire this after the social provider callback succeeds and the user
+     * is authenticated. Include the `provider` and user reference.
+     *
+     * @param data - Event payload containing the `provider` and user reference.
+     * @param tags - Optional key-value tags for filtering and segmentation.
+     * @param contexts - Optional contextual metadata attached to the event.
+     *
+     * @example
+     * ```typescript
+     * tracker.socialLoginFinish({ provider: "google" });
+     * ```
+     */
+    socialLoginFinish(data: SocialLoginFinish, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    /**
+     * Track when the overall login flow finishes successfully.
+     *
+     * @remarks
+     * Fire this as the final event of a successful login, regardless of the
+     * authentication method used. This closes the login funnel that started
+     * with {@link loginVisible}.
+     *
+     * @param data - Event payload (currently empty, reserved for future fields).
+     * @param tags - Optional key-value tags for filtering and segmentation.
+     * @param contexts - Optional contextual metadata attached to the event.
+     *
+     * @example
+     * ```typescript
+     * tracker.loginFinish();
+     * ```
+     */
+    loginFinish(data?: LoginFinish, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    /**
+     * Track when the signup UI becomes visible to the user.
+     *
+     * @remarks
+     * Trigger this event when your signup form or registration page is rendered
+     * and visible. Optionally use the `touchpoint` field to distinguish where the
+     * signup appears (e.g. a dedicated registration page vs. an inline checkout signup).
+     *
+     * @param data - Event payload with an optional `touchpoint`.
+     * @param tags - Optional key-value tags for filtering and segmentation.
+     * @param contexts - Optional contextual metadata attached to the event.
+     *
+     * @example
+     * ```typescript
+     * tracker.signupVisible({});
+     * ```
+     */
+    signupVisible(data: SignupVisible, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    /**
+     * Track when the signup flow completes and associate the new user.
+     *
+     * @remarks
+     * Fire this after a new account has been created. If `userId` and/or
+     * `identifier` are provided they are extracted and attached as a
+     * {@link UserReference} so subsequent events can be correlated to this user.
+     *
+     * @param data - Event payload, optionally containing `userId` and/or `identifier`.
+     * @param tags - Optional key-value tags for filtering and segmentation.
+     * @param contexts - Optional contextual metadata attached to the event.
+     *
+     * @example
+     * ```typescript
+     * tracker.signupFinish({});
+     * ```
+     */
+    signupFinish(data: SignupFinish, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    /**
+     * Track when the user is offered a choice between login methods.
+     *
+     * @remarks
+     * Fire this when your UI presents multiple authentication methods and the
+     * user must choose one. Record `availableMethods` using {@link LoginMethodType}
+     * values and, if applicable, the `explicitDecisionValue` the user selected.
+     *
+     * @param data - Event payload with `decisionName`, `availableMethods`, and optional `explicitDecisionValue`.
+     *
+     * @example
+     * ```typescript
+     * tracker.loginMethodsDecisionOffered({
+     *   decisionName: "d1",
+     *   availableMethods: ["passkey-conditional-ui", "identifier-email", "social-google"],
+     * });
+     * ```
+     */
+    loginMethodsDecisionOffered(data: LoginMethodDecision): void;
+    authDecisionVisible(data: AuthDecisionVisible): void;
+    authDecisionFinished(data: AuthDecisionFinished): void;
+    /**
+     * Track when a security enrollment flow starts.
+     *
+     * @remarks
+     * Fire this when the user begins enrolling a new security credential
+     * (e.g. passkey, MFA device). The `touchpoint` indicates where enrollment
+     * was triggered (e.g. `"post-account"`, `"settings"`), and the `userId`
+     * is extracted as a {@link UserReference}.
+     *
+     * @param data - Event payload with `touchpoint` and `userId`.
+     * @param tags - Optional key-value tags for filtering and segmentation.
+     * @param contexts - Optional contextual metadata attached to the event.
+     *
+     * @example
+     * ```typescript
+     * tracker.securityEnrollmentStarted({ touchpoint: "post-account", userId: "usr_123" });
+     * ```
+     */
+    securityEnrollmentStarted(data: SecurityEnrollmentStarted, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    /**
+     * Track when a security enrollment completes successfully.
+     *
+     * @remarks
+     * Fire this after the new security credential has been registered
+     * and persisted.
+     *
+     * @param data - Event payload (currently empty, reserved for future fields).
+     * @param tags - Optional key-value tags for filtering and segmentation.
+     * @param contexts - Optional contextual metadata attached to the event.
+     *
+     * @example
+     * ```typescript
+     * tracker.securityEnrollmentFinished({});
+     * ```
+     */
+    securityEnrollmentFinished(data: {}, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    /**
+     * Create a trackable passkey enrollment operation and mark it as startable.
+     *
+     * @remarks
+     * Returns a {@link PasskeyOperationEnrollment} that manages the full
+     * enrollment lifecycle: `started` → `submitted` → `finished` / `error` / `skipped`.
+     * Call this when the user reaches a point where passkey enrollment can be offered.
+     *
+     * @param data - Event payload (currently empty, reserved for future fields).
+     * @param tags - Optional key-value tags for filtering and segmentation.
+     * @param contexts - Optional contextual metadata attached to the event.
+     * @returns A {@link PasskeyOperationEnrollment} instance.
+     *
+     * @example
+     * ```typescript
+     * const op = tracker.passkeyEnrollmentStartable({});
+     * ```
+     */
+    passkeyEnrollmentStartable(data: PasskeyEnrollmentStartable, tags?: Record<string, string>, contexts?: Record<string, any>): PasskeyOperationEnrollment;
+    /**
+     * Track when an account recovery flow starts.
+     *
+     * @remarks
+     * Fire this when the user initiates account recovery (e.g. "Forgot password",
+     * "Can't sign in"). Use the `touchpoint` field to indicate where recovery was
+     * triggered.
+     *
+     * @param data - Event payload with `touchpoint`.
+     * @param tags - Optional key-value tags for filtering and segmentation.
+     * @param contexts - Optional contextual metadata attached to the event.
+     *
+     * @example
+     * ```typescript
+     * tracker.accountRecoveryStarted({ touchpoint: "login" });
+     * ```
+     */
+    accountRecoveryStarted(data: AccountRecoveryStarted, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    /**
+     * Track when an account recovery flow completes successfully.
+     *
+     * @remarks
+     * Fire this after the user has successfully recovered access to their account.
+     *
+     * @param data - Event payload (currently empty, reserved for future fields).
+     * @param tags - Optional key-value tags for filtering and segmentation.
+     * @param contexts - Optional contextual metadata attached to the event.
+     *
+     * @example
+     * ```typescript
+     * tracker.accountRecoveryFinished({});
+     * ```
+     */
+    accountRecoveryFinished(data: {}, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    /**
+     * Track when an email link flow starts.
+     *
+     * @remarks
+     * Fire this when the email has been sent out to the user and the verification process begins.
+     * If fired from an un-authenticated context, we recommend to include a `crossEnvironmentTransactionID` in `data`.
+     * This can be any idea that you have again available when the email link flow submits (after the user clicks the link in the email).
+     *
+     * @param data - Event payload containing the user reference.
+     * @param tags - Optional key-value tags for filtering and segmentation.
+     * @param contexts - Optional contextual metadata attached to the event.
+     *
+     * @example
+     * ```typescript
+     * tracker.emailLinkStarted({ userId: "usr_123" });
+     * ```
+     */
+    emailLinkStartable(data: EmailLinkStartable, tags?: Record<string, string>, contexts?: Record<string, any>): EmailLinkOperation;
+    emailLinkSubmitted(data: EmailLinkSubmitted, tags?: Record<string, string>, contexts?: Record<string, any>): EmailLinkOperation;
+    emailLinkFinished(data: EmailLinkFinished, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    emailLinkError(data: EmailLinkError, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    /**
+     * Create a trackable email OTP operation and mark it as startable.
+     *
+     * @remarks
+     * Returns an {@link EmailOTPOperation} that manages the full email OTP
+     * lifecycle: `started` → `submitted` → `finished` / `error`, plus `resent`.
+     * Call this when the user reaches a point where email OTP authentication
+     * can be offered (e.g. after identifier provision returns email OTP as
+     * an available method).
+     *
+     * @param data - Event payload (currently empty, reserved for future fields).
+     * @param tags - Optional key-value tags for filtering and segmentation.
+     * @param contexts - Optional contextual metadata attached to the event.
+     * @returns An {@link EmailOTPOperation} instance.
+     *
+     * @example
+     * ```typescript
+     * const op = tracker.emailOTPStartable({});
+     * ```
+     */
+    emailOTPStartable(data?: EmailOTPStartable, tags?: Record<string, string>, contexts?: Record<string, any>): EmailOTPOperation;
+    /**
+     * Track the start of an email OTP authentication flow.
+     *
+     * @remarks
+     * Fire this when the email OTP flow begins — typically when the OTP email
+     * is sent to the user. The returned {@link EmailOTPOperation} lets you
+     * continue tracking through submission, completion, error, or resend.
+     *
+     * @param data - Event payload (currently empty, reserved for future fields).
+     * @param tags - Optional key-value tags for filtering and segmentation.
+     * @param contexts - Optional contextual metadata attached to the event.
+     * @returns An {@link EmailOTPOperation} instance.
+     *
+     * @example
+     * ```typescript
+     * const op = tracker.emailOTPStarted({});
+     * ```
+     */
+    emailOTPStarted(data?: EmailOTPStarted, tags?: Record<string, string>, contexts?: Record<string, any>): EmailOTPOperation;
+    /**
+     * Track when the user submits an email OTP code.
+     *
+     * @remarks
+     * Fire this after the user enters and submits the OTP code for verification.
+     * This sits between the started and finished/error events.
+     *
+     * @param data - Event payload (currently empty, reserved for future fields).
+     * @param tags - Optional key-value tags for filtering and segmentation.
+     * @param contexts - Optional contextual metadata attached to the event.
+     *
+     * @example
+     * ```typescript
+     * tracker.emailOTPSubmitted({});
+     * ```
+     */
+    emailOTPSubmitted(data?: EmailOTPSubmitted, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    /**
+     * Track when email OTP verification completes successfully.
+     *
+     * @remarks
+     * Fire this after the backend has verified the OTP code and the user
+     * is authenticated.
+     *
+     * @param data - Event payload (currently empty, reserved for future fields).
+     * @param tags - Optional key-value tags for filtering and segmentation.
+     * @param contexts - Optional contextual metadata attached to the event.
+     *
+     * @example
+     * ```typescript
+     * tracker.emailOTPFinished({});
+     * ```
+     */
+    emailOTPFinished(data?: EmailOTPFinished, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    /**
+     * Track when email OTP verification fails.
+     *
+     * @remarks
+     * Fire this when OTP code verification fails (e.g. invalid code, expired code,
+     * rate limit exceeded).
+     *
+     * @param data - Event payload containing the `errorCode`.
+     * @param tags - Optional key-value tags for filtering and segmentation.
+     * @param contexts - Optional contextual metadata attached to the event.
+     *
+     * @example
+     * ```typescript
+     * tracker.emailOTPError({ errorCode: "invalid_code" });
+     * ```
+     */
+    emailOTPError(data: EmailOTPError, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    /**
+     * Track when an email OTP code is resent.
+     *
+     * @remarks
+     * Fire this when the user requests a new OTP code (e.g. clicks "Resend code").
+     * This helps measure how often users need to request a new code.
+     *
+     * @param data - Event payload (currently empty, reserved for future fields).
+     * @param tags - Optional key-value tags for filtering and segmentation.
+     * @param contexts - Optional contextual metadata attached to the event.
+     *
+     * @example
+     * ```typescript
+     * tracker.emailOTPResent({});
+     * ```
+     */
+    emailOTPResent(data?: EmailOTPResent, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    setPasswordStartable(inputHtmlField?: HTMLInputElement, tags?: Record<string, string>, contexts?: Record<string, any>): SetPasswordOperation;
+    setPasswordStarted(data?: SetPasswordStarted, tags?: Record<string, string>, contexts?: Record<string, any>): SetPasswordOperation;
+    setPasswordSubmitted(data?: SetPasswordSubmitted, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    setPasswordFinished(data?: SetPasswordFinished, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    setPasswordError(data: SetPasswordError, tags?: Record<string, string>, contexts?: Record<string, any>): void;
+    /** @internal */
+    resetSession(): string;
+}
+
+declare const SDK_NAME = "@corbado/observe";
+declare const SDK_VERSION: string;
+
+interface TransportMakeRequestResponse {
+    statusCode?: number;
+    headers?: Record<string, string | null>;
+}
+interface Transport {
+    send(batch: EventBatch): Promise<TransportMakeRequestResponse>;
+    sendBeacon?(batch: EventBatch): boolean;
+    flush(timeout?: number): Promise<boolean>;
+}
+interface TransportOptions {
+    url: string;
+    headers?: Record<string, string>;
+}
+
+interface QueueOptions {
+    batchSize?: number;
+    flushInterval?: number;
+}
+declare class RequestQueue {
+    private transport;
+    private readonly projectId;
+    private sessionId;
+    private readonly sdk;
+    private options;
+    private queue;
+    private timer;
+    private isFlushing;
+    private onVisibilityChange;
+    private onPageHide;
+    constructor(transport: Transport, projectId: string, sessionId: string, sdk: SdkInfo, options?: QueueOptions);
+    setSessionId(sessionId: string): void;
+    enqueue(event: Event): void;
+    flush(): Promise<void>;
+    private setupLifecycleHooks;
+    private flushSync;
+    destroy(): void;
+}
+
+interface StorageEngine {
+    getItem<T>(key: string): T | null;
+    setItem<T>(key: string, value: T): void;
+    removeItem(key: string): void;
+}
+declare class LocalStorage implements StorageEngine {
+    getItem<T>(key: string): T | null;
+    setItem<T>(key: string, value: T): void;
+    removeItem(key: string): void;
+}
+declare class CookieStorage implements StorageEngine {
+    private domain?;
+    constructor(domain?: string | undefined);
+    getItem<T>(key: string): T | null;
+    setItem<T>(key: string, value: T): void;
+    removeItem(key: string): void;
+}
+declare class SessionStorage implements StorageEngine {
+    getItem<T>(key: string): T | null;
+    setItem<T>(key: string, value: T): void;
+    removeItem(key: string): void;
+}
+
+declare function init(options: TrackerOptions): CorbadoTracker;
+declare function getTracker(): CorbadoTracker | undefined;
+declare function resetSession(): string | undefined;
+
+export { type AccountRecoveryStarted, type AuthDecisionFinished, type AuthDecisionVisible, AuthEventName, type BaseEvent, type ClientCapabilities, type ClientEnvHandleMeta, type ClientEnvHandleMetaSource, CookieStorage, CorbadoTracker, type CustomEvent, type DeviceInfo, type DeviceInfoDataWeb, type DeviceType, type EmailLinkError, type EmailLinkFinished, EmailLinkOperation, type EmailLinkStartable, type EmailLinkSubmitted, type EmailOTPError, type EmailOTPFinished, EmailOTPOperation, type EmailOTPResent, type EmailOTPStartable, type EmailOTPStarted, type EmailOTPSubmitted, type Event, type EventBatch, type EventType, type IdentifierProvided, type JavaScriptHighEntropy, LocalStorage, type LoginFinish, type LoginMethodDecision, type LoginMethodType, type LoginReset, type LoginStepPasswordErrorCode, type LoginVisible, type NormalizedError, type PasskeyEnrollmentError, type PasskeyEnrollmentFinished, type PasskeyEnrollmentStartable, type PasskeyEnrollmentStarted, type PasskeyEnrollmentSubmitted, type PasskeyLoginClientError, type PasskeyLoginFinish, type PasskeyLoginStart, type PasskeyLoginStartable, type PasskeyLoginSubmitted, PasskeyOperationEnrollment, PasskeyOperationLogin, type PasswordLoginError, type PasswordLoginFinish, type PasswordLoginStartable, type PasswordLoginStarted, PasswordOperationLogin, type PredefinedEvent, type ProvideIdentifierError, type ProvideIdentifierFinish, ProvideIdentifierOperation, type ProvideIdentifierStart, type QueueOptions, RequestQueue, SDK_NAME, SDK_VERSION, type SdkInfo, type SecurityEnrollmentStarted, SessionStorage, type SetPasswordError, type SetPasswordFinished, SetPasswordOperation, type SetPasswordStartable, type SetPasswordStarted, type SetPasswordSubmitted, type SignupFinish, type SignupVisible, type SocialLoginError, type SocialLoginFinish, type SocialLoginProviderType, type SocialLoginStart, SocialOperationLogin, type StorageEngine, type TrackerOptions, type Transport, type TransportMakeRequestResponse, type TransportOptions, type User, type UserReference, type WithSubFlowId, getTracker, init, resetSession };