@thunderid/javascript 0.3.0 → 0.3.6

package/dist/models/embedded-flow.d.ts

@@ -21,142 +21,622 @@ export declare enum EmbeddedFlowType {
     Registration = "REGISTRATION",
     UserOnboarding = "USER_ONBOARDING"
 }
-export interface EmbeddedFlowExecuteRequestPayload {
-    actionId?: string;
-    flowType: EmbeddedFlowType;
-    inputs?: Record<string, any>;
-}
-export interface EmbeddedFlowExecuteResponse {
-    data: EmbeddedSignUpFlowData;
-    flowId: string;
-    flowStatus: EmbeddedFlowStatus;
-    type: EmbeddedFlowResponseType;
-}
-export declare enum EmbeddedFlowStatus {
-    Complete = "COMPLETE",
-    Incomplete = "INCOMPLETE"
-}
 export declare enum EmbeddedFlowResponseType {
     Redirection = "REDIRECTION",
     View = "VIEW"
 }
-export interface EmbeddedSignUpFlowData {
-    additionalData?: Record<string, any>;
-    components?: EmbeddedFlowComponent[];
-    redirectURL?: string;
+/**
+ * Base request configuration for executing embedded flow operations.
+ *
+ * @template T - Type of the payload data being sent with the request
+ */
+export interface EmbeddedFlowExecuteRequestConfigBase<T = any> extends Partial<Request> {
+    baseUrl?: string;
+    payload?: T;
+    url?: string;
 }
-export interface EmbeddedFlowComponent {
-    components: EmbeddedFlowComponent[];
-    config: Record<string, unknown>;
-    id: string;
-    type: EmbeddedFlowComponentType | string;
-    variant?: string;
+/**
+ * Internationalized message structure returned by the backend.
+ *
+ * The `defaultValue` field carries the untranslated fallback text.
+ */
+export interface I18nMessage {
+    defaultValue?: string;
+    key: string;
+}
+/**
+ * Structured error returned in a flow response when flowStatus is ERROR.
+ */
+export interface FlowExecutionError {
+    code: string;
+    description: I18nMessage;
+    message: I18nMessage;
 }
+/**
+ * Component types supported by the ThunderID embedded flow API.
+ *
+ * These types define the different UI components that can be rendered
+ * as part of the embedded authentication flows. Each type corresponds
+ * to a specific UI element with its own behavior and properties.
+ *
+ * @example
+ * ```typescript
+ * // Check component type to render appropriate UI
+ * if (component.type === EmbeddedFlowComponentType.TextInput) {
+ *   // Render text input field
+ * } else if (component.type === EmbeddedFlowComponentType.Action) {
+ *   // Render button/action
+ * }
+ * ```
+ *
+ * @experimental This API may change in future versions
+ */
 export declare enum EmbeddedFlowComponentType {
-    Button = "BUTTON",
-    Checkbox = "CHECKBOX",
+    /** Interactive action component (buttons, links) for user interactions */
+    Action = "ACTION",
+    /** Container block component that groups other components */
+    Block = "BLOCK",
+    /** Consent component for displaying consent purposes and attributes */
+    Consent = "CONSENT",
+    /** Copyable text display component that shows text with a copy-to-clipboard action */
+    CopyableText = "COPYABLE_TEXT",
+    /** Date input field for selecting a calendar date */
+    DateInput = "DATE_INPUT",
+    /** Divider component for visual separation of content */
     Divider = "DIVIDER",
-    Form = "FORM",
+    /** Email input field with validation for email addresses. */
+    EmailInput = "EMAIL_INPUT",
+    /** Icon display component for rendering named vector icons */
+    Icon = "ICON",
+    /** Image display component for logos and illustrations */
     Image = "IMAGE",
-    Input = "INPUT",
-    Radio = "RADIO",
+    /** One-time password input field for multi-factor authentication */
+    OtpInput = "OTP_INPUT",
+    /** Organization unit tree picker for selecting an OU */
+    OuSelect = "OU_SELECT",
+    /** Password input field with masking for sensitive data */
+    PasswordInput = "PASSWORD_INPUT",
+    /** Phone number input field with country code support */
+    PhoneInput = "PHONE_INPUT",
+    /** Rich text display component that renders formatted HTML content */
+    RichText = "RICH_TEXT",
+    /** Select/dropdown input component for single choice selection */
     Select = "SELECT",
-    Typography = "TYPOGRAPHY"
+    /** Stack layout component for arranging children in a row or column */
+    Stack = "STACK",
+    /** Text display component for labels, headings, and messages */
+    Text = "TEXT",
+    /** Standard text input field for user data entry */
+    TextInput = "TEXT_INPUT",
+    /** Timer component for displaying a countdown */
+    Timer = "TIMER",
+    /** QR code display component for wallet-based flows (e.g. OpenID4VP) */
+    QrCode = "QR_CODE"
 }
 /**
- * Request configuration for executing embedded flow operations.
+ * Action variant types for buttons and interactive elements.
  *
- * This interface extends standard HTTP request configuration with additional
- * properties specific to embedded flow execution, such as base URL and payload data.
+ * @experimental This API may change in future versions
+ */
+export declare enum EmbeddedFlowActionVariant {
+    /** Danger action button for destructive operations */
+    Danger = "DANGER",
+    /** Info action button for informational purposes */
+    Info = "INFO",
+    /** Link-styled action button */
+    Link = "LINK",
+    /** Outlined action button for secondary emphasis */
+    Outlined = "OUTLINED",
+    /** Primary action button with highest visual emphasis */
+    Primary = "PRIMARY",
+    /** Secondary action button with moderate visual emphasis */
+    Secondary = "SECONDARY",
+    /** Success action button for positive confirmations */
+    Success = "SUCCESS",
+    /** Tertiary action button with minimal visual emphasis */
+    Tertiary = "TERTIARY",
+    /** Warning action button for cautionary actions */
+    Warning = "WARNING"
+}
+/**
+ * Text variant types for typography components.
  *
- * @template T - Type of the payload data being sent with the request
+ * @experimental This API may change in future versions
+ */
+export declare enum EmbeddedFlowTextVariant {
+    /** Primary body text for main content */
+    Body1 = "BODY_1",
+    /** Secondary body text for supplementary content */
+    Body2 = "BODY_2",
+    /** Text styled for button labels */
+    ButtonText = "BUTTON_TEXT",
+    /** Small caption text for annotations and descriptions */
+    Caption = "CAPTION",
+    /** Largest heading level for main titles */
+    Heading1 = "HEADING_1",
+    /** Second level heading for major sections */
+    Heading2 = "HEADING_2",
+    /** Third level heading for subsections */
+    Heading3 = "HEADING_3",
+    /** Fourth level heading for minor sections */
+    Heading4 = "HEADING_4",
+    /** Fifth level heading for detailed sections */
+    Heading5 = "HEADING_5",
+    /** Smallest heading level for fine-grained sections */
+    Heading6 = "HEADING_6",
+    /** Overline text for labels and categories */
+    Overline = "OVERLINE",
+    /** Primary subtitle text with larger emphasis */
+    Subtitle1 = "SUBTITLE_1",
+    /** Secondary subtitle text with moderate emphasis */
+    Subtitle2 = "SUBTITLE_2"
+}
+/**
+ * Event types for action components.
+ *
+ * @experimental This API may change in future versions
+ */
+export declare enum EmbeddedFlowEventType {
+    /** Navigate back to the previous step */
+    Back = "BACK",
+    /** Cancel the current operation */
+    Cancel = "CANCEL",
+    /** Navigate to a different flow step or page */
+    Navigate = "NAVIGATE",
+    /** Reset form fields to initial state */
+    Reset = "RESET",
+    /** Submit form data to the server */
+    Submit = "SUBMIT",
+    /** Trigger an action or event */
+    Trigger = "TRIGGER"
+}
+/**
+ * Enhanced component interface for embedded flow components.
+ *
+ * This interface provides better support for modern form handling and user experience.
+ * It includes properties for labels, placeholders, and required field validation
+ * that are directly provided by the API response.
+ *
+ * @example
+ * ```typescript
+ * const component: EmbeddedFlowComponent = {
+ *   id: 'username_field',
+ *   type: EmbeddedFlowComponentType.TextInput,
+ *   label: 'Username',
+ *   placeholder: 'Enter your username',
+ *   required: true,
+ *   variant: 'TEXT',
+ *   eventType: 'SUBMIT',
+ *   components: []
+ * };
+ * ```
+ *
+ * @experimental This interface may change in future versions
  */
-export interface EmbeddedFlowExecuteRequestConfig<T = any> extends Partial<Request> {
+export interface EmbeddedFlowComponent {
     /**
-     * Base URL for the API endpoint.
-     * This is typically the ThunderID organization URL.
+     * Alignment of children along the cross axis (for Stack components).
      */
-    baseUrl?: string;
+    align?: string;
     /**
-     * Payload data to be sent with the request.
-     * The structure depends on the specific flow operation being executed.
+     * Alternative text for Image components.
      */
-    payload?: T;
+    alt?: string;
     /**
-     * Full URL for the API endpoint.
-     * If provided, this overrides the baseUrl.
+     * Icon color, CSS color value (for Icon components).
      */
-    url?: string;
+    color?: string;
+    /**
+     * Nested child components for container components like Block and Stack.
+     */
+    components?: EmbeddedFlowComponent[];
+    /**
+     * Display format hint for DateInput components (e.g., 'yyyy-MM-dd'). Used as the
+     * placeholder rendered by the date picker primitive. Pattern-level validation is
+     * declared separately via a `regex` rule in the `validation` array.
+     */
+    dateFormat?: string;
+    /**
+     * Layout direction for Stack components ('row' | 'column').
+     */
+    direction?: string;
+    /**
+     * Icon to render at the end of an Action button (URL string).
+     */
+    endIcon?: string;
+    /**
+     * Event type for action components that defines the interaction behavior.
+     * Only relevant for Action components.
+     */
+    eventType?: EmbeddedFlowEventType | string;
+    /**
+     * Gap between children in Stack components (number, maps to spacing units).
+     */
+    gap?: number;
+    /**
+     * Height of the component (for Image components, can be string with units or number for pixels).
+     * The value depends on the component type (e.g., for Image components).
+     */
+    height?: string | number;
+    /**
+     * Legacy flat configuration bag for V1 adapter-based components.
+     */
+    config?: Record<string, unknown>;
+    /**
+     * Unique identifier for the component
+     */
+    id: string;
+    /**
+     * Number of items across the main axis (for Stack grid-like layouts).
+     */
+    items?: string | number;
+    /**
+     * Justification of children along the main axis (for Stack components).
+     */
+    justify?: string;
+    /**
+     * Display label for the component (e.g., field label, button text).
+     * Supports internationalization and may contain template strings.
+     */
+    label?: string;
+    /**
+     * Icon name for Icon components (e.g., lucide-react icon names like 'ArrowLeftRight').
+     */
+    name?: string;
+    /**
+     * Options for SELECT components.
+     * Each option can be a string value or an object with value and label.
+     */
+    options?: (string | {
+        label: string;
+        value: string;
+    })[];
+    /**
+     * Placeholder text for input components.
+     * Provides helpful hints to users about expected input format.
+     */
+    placeholder?: string;
+    /**
+     * Reference identifier for the component (e.g., field name, action ref)
+     */
+    ref?: string;
+    /**
+     * Indicates whether this component represents a required field.
+     * Used for form validation and UI indicators.
+     */
+    required?: boolean;
+    /**
+     * Icon size in pixels (for Icon components).
+     */
+    size?: number;
+    /**
+     * Data source key for dynamic components (e.g., COPYABLE_TEXT).
+     * References a key in additionalData whose value is resolved at render time.
+     */
+    source?: string;
+    /**
+     * Image source URL (for Image components).
+     */
+    src?: string;
+    /**
+     * Icon to render at the start of an Action button (URL string).
+     */
+    startIcon?: string;
+    /**
+     * Component type that determines rendering behavior
+     */
+    type: EmbeddedFlowComponentType | string;
+    /**
+     * Declarative validation rules for input components. Evaluated client-side by the SDK
+     * (best-effort UX) before submission, and authoritatively re-evaluated server-side.
+     * Each rule represents exactly one constraint.
+     */
+    validation?: ValidationRule[];
+    /**
+     * Component variant that affects visual styling and behavior.
+     * The value depends on the component type (e.g., button variants, text variants).
+     */
+    variant?: EmbeddedFlowActionVariant | EmbeddedFlowTextVariant | string;
+    /**
+     * Width of the component (for Image components, can be string with units or number for pixels).
+     * The value depends on the component type (e.g., for Image components).
+     */
+    width?: string | number;
+}
+/**
+ * Supported validation rule types for `ValidationRule.type`.
+ *
+ * - `regex`: value must be a string regex pattern; the input must match.
+ * - `minLength`: value must be a number; input length must be >= value.
+ * - `maxLength`: value must be a number; input length must be <= value.
+ *
+ * @experimental Additional rule types (`oneOf`, `format`, ...) may be added later.
+ */
+export type ValidationRuleType = 'regex' | 'minLength' | 'maxLength';
+/**
+ * A single-constraint validation rule attached to an input component.
+ * Mirrors the server-side `ValidationRule` returned by ThunderID.
+ *
+ * @experimental This interface may change in future versions
+ */
+export interface ValidationRule {
+    /**
+     * The constraint kind. Drives interpretation of `value` and the default fallback message.
+     */
+    type: ValidationRuleType;
+    /**
+     * The constraint parameter. String for `regex`, number for `minLength` / `maxLength`.
+     */
+    value: string | number;
+    /**
+     * Optional message returned when this rule fails. May be an i18n key (e.g.
+     * `"{{i18n(validation:email.invalid)}}"`) or a literal string. The server passes
+     * this through unchanged; the SDK substitutes a default i18n key when omitted.
+     */
+    message?: string;
 }
 /**
- * Error response structure for ThunderIDV1 embedded flow operations.
+ * A single validation failure for a specific input field returned by the server in
+ * `data.fieldErrors` when one or more rules fail.
  *
- * This interface defines the structure of error responses returned by ThunderIDV1 APIs
- * when flow operations (such as sign-up or sign-in) fail.
+ * @experimental This interface may change in future versions
+ */
+export interface FieldError {
+    /** The `identifier` of the input that failed validation. */
+    identifier: string;
+    /** The failing rule's message (i18n key or literal string). */
+    message: string;
+}
+/**
+ * Response data structure for embedded flow API.
  *
- * **Key Characteristics:**
- * - Uses structured error codes (e.g., "FEE-60005") for programmatic error handling
- * - Provides both a brief `message` and detailed `description` for context
- * - Includes `flowType` to identify which flow operation failed
+ * This interface defines the structure of data returned by the API,
+ * which includes both legacy input/action arrays for backward compatibility
+ * and the new meta.components structure for modern component-driven UIs.
  *
- * **Error Handling:**
- * This error response format is automatically detected and processed by the
- * `extractErrorMessage()` and `checkForErrorResponse()` functions in the React
- * transformer to extract meaningful error messages for display to users.
+ * The key improvement is the meta.components field, which provides
+ * a rich component tree with proper labels, placeholders, and hierarchy
+ * that can be directly rendered without additional transformation.
  *
  * @example
  * ```typescript
- * // Typical ThunderIDV1 error response
- * const errorResponse: EmbeddedFlowExecuteErrorResponse = {
- *   code: "FEE-60005",
- *   message: "Error while provisioning user.",
- *   description: "Error occurred while provisioning user in the request of flow id: ac57315c-6ca6-49dc-8664-fcdcff354f46",
- *   flowType: "REGISTRATION"
+ * const response: EmbeddedFlowResponseData = {
+ *   // Legacy format (for backward compatibility)
+ *   inputs: [
+ *     { ref: 'input_001', identifier: 'username', type: 'TEXT_INPUT', required: true }
+ *   ],
+ *   actions: [
+ *     { ref: 'action_001', nextNode: 'basic_auth', eventType: 'SUBMIT' }
+ *   ],
+ *   // Modern format (recommended)
+ *   meta: {
+ *     components: [
+ *       {
+ *         id: 'text_001',
+ *         type: 'TEXT',
+ *         label: '{{ t(signin:heading.label) }}',
+ *         variant: 'HEADING_1'
+ *       },
+ *       {
+ *         id: 'block_001',
+ *         type: 'BLOCK',
+ *         components: [
+ *           {
+ *             id: 'input_001',
+ *             type: 'TEXT_INPUT',
+ *             label: '{{ t(signin:fields.username.label) }}',
+ *             placeholder: '{{ t(signin:fields.username.placeholder) }}',
+ *             required: true
+ *           },
+ *           {
+ *             id: 'action_001',
+ *             type: 'ACTION',
+ *             label: '{{ t(signin:buttons.submit.label) }}',
+ *             variant: 'PRIMARY',
+ *             eventType: 'ACTIVATE'
+ *           }
+ *         ]
+ *       }
+ *     ]
+ *   }
  * };
- *
- * // The transformer will extract: "Error occurred while provisioning user in the request of flow id: ac57315c-6ca6-49dc-8664-fcdcff354f46"
- * // (Prefers description over message as it's usually more detailed)
  * ```
  *
- * @see {@link EmbeddedSignUpFlowErrorResponse} for the ThunderIDV2 equivalent error structure
+ * @experimental This structure may change in future versions
  */
-export interface EmbeddedFlowExecuteErrorResponse {
+export interface EmbeddedFlowResponseData {
     /**
-     * Structured error code identifying the type of error.
-     *
-     * Format typically follows pattern like "FEE-XXXXX" where:
-     * - "FEE" indicates Flow Execution Error
-     * - XXXXX is a numeric identifier for the specific error type
-     *
-     * @example "FEE-60005" - User provisioning error
+     * Legacy action definitions for backward compatibility.
+     * @deprecated Use meta.components for new implementations
      */
-    code: string;
+    actions?: {
+        /** Event type for the action (SUBMIT, ACTIVATE, etc.) */
+        eventType?: string;
+        /** Next flow node to navigate to (optional) */
+        nextNode?: string;
+        /** Reference identifier for the action */
+        ref: string;
+    }[];
     /**
-     * Detailed error description with contextual information.
-     *
-     * This field usually contains more specific information about the error,
-     * including flow IDs, operation details, and other debugging context.
-     * The transformer prefers this field over `message` when extracting
-     * error messages for display to users.
+     * Additional data dictionary for dynamic flow response properties.
+     * Can be used to pass custom data like passkey challenges, server alerts, etc.
+     */
+    additionalData?: Record<string, any>;
+    /**
+     * Per-field validation errors returned by the server when a submission fails one or
+     * more `validation` rules. Multiple failing rules on the same field appear as
+     * multiple entries, in the order the rules were declared.
      *
-     * @example "Error occurred while provisioning user in the request of flow id: ac57315c-6ca6-49dc-8664-fcdcff354f46"
+     * Present only on `INCOMPLETE` responses caused by validation failures; absent on
+     * successful submissions and on `INCOMPLETE` responses caused by missing required fields.
      */
-    description: string;
+    fieldErrors?: FieldError[];
     /**
-     * Type of flow operation that encountered the error.
+     * Legacy input definitions for backward compatibility.
+     * @deprecated Use meta.components for new implementations
+     */
+    inputs?: {
+        /** Field identifier used in form submission */
+        identifier: string;
+        /** Reference identifier for the input */
+        ref: string;
+        /** Whether this input is required for form submission */
+        required: boolean;
+        /** Input type (TEXT_INPUT, PASSWORD_INPUT, etc.) */
+        type: string;
+        /** Server-side validation rules for the input (also returned for API-only customers). */
+        validation?: ValidationRule[];
+    }[];
+    /**
+     * Modern component-driven metadata structure.
+     * This contains the complete UI component tree with proper
+     * hierarchy, labels, and configuration that can be directly rendered.
      *
-     * Currently only supports 'REGISTRATION' but may be extended to
-     * include other flow types (e.g., 'LOGIN', 'PASSWORD_RESET') in the future.
+     * **This is the primary data source for implementations.**
+     * The legacy inputs/actions arrays are maintained only for backward compatibility.
+     */
+    meta?: {
+        /** Array of components that define the complete UI structure */
+        components: EmbeddedFlowComponent[];
+    };
+    /**
+     * Optional redirect URL for flow completion or external authentication.
+     */
+    redirectURL?: string;
+}
+/**
+ * Discriminator identifying the kind of consent a purpose represents. The same
+ * `ConsentPurposeData` envelope is used for both attribute and permission consent;
+ * the populated fields differ based on this discriminator.
+ *
+ * @experimental This type may change in future versions
+ */
+export type ConsentPurposeType = 'attributes' | 'permissions';
+/**
+ * Individual consent attribute/element decision.
+ *
+ * @experimental This interface may change in future versions
+ */
+export interface ConsentAttributeElement {
+    /** Whether the user approved collection of this attribute */
+    approved: boolean;
+    /** The name of the attribute being consented */
+    name: string;
+}
+/**
+ * A single element presented for consent within a consent purpose. For attribute purposes
+ * the element is an attribute name. For permission purposes the element is a permission
+ * string and `parent` may carry rollup linkage supplied by the server: when set, the UI
+ * may render this permission as a child of `parent` and offer a single rollup toggle.
+ *
+ * @experimental This interface may change in future versions
+ */
+export interface PromptElement {
+    /** Canonical element name (attribute name or permission string) */
+    name: string;
+    /**
+     * Canonical name of the rollup parent, permission-purpose only. Undefined for attribute
+     * elements and for top-level permissions.
+     */
+    parent?: string;
+}
+/**
+ * Consent decision for a single purpose.
+ *
+ * @experimental This interface may change in future versions
+ */
+export interface ConsentPurposeDecision {
+    /** Whether the user approved this purpose */
+    approved: boolean;
+    /** Per-attribute decisions for this purpose */
+    elements: ConsentAttributeElement[];
+    /** The name of the consent purpose */
+    purposeName: string;
+}
+/**
+ * Full consent decisions structure sent to the backend when user submits the consent form.
+ *
+ * @experimental This interface may change in future versions
+ */
+export interface ConsentDecisions {
+    /** Array of per-purpose decisions */
+    purposes: ConsentPurposeDecision[];
+}
+/**
+ * Single consent purpose data returned by the backend in additionalData.consent_prompt.
+ * The same envelope carries both attribute and permission purposes, distinguished by `type`.
+ *
+ * @experimental This interface may change in future versions
+ */
+export interface ConsentPurposeData {
+    /** Optional human-readable description of the purpose */
+    description?: string;
+    /**
+     * Elements that are mandatory and cannot be declined. Used by attribute purposes;
+     * permission purposes today have no essential elements.
      */
-    flowType: 'REGISTRATION' | 'RECOVERY';
+    essential: PromptElement[];
     /**
-     * Brief error message describing what went wrong.
+     * Elements the user can opt in or out of. For attribute purposes these are optional
+     * attribute names. For permission purposes these are permission elements (which may
+     * carry rollup parent linkage).
+     */
+    optional: PromptElement[];
+    /** Unique identifier for the purpose */
+    purposeId: string;
+    /** Human-readable purpose name */
+    purposeName?: string;
+    /**
+     * Discriminator selecting between attribute and permission consent semantics.
+     */
+    type?: ConsentPurposeType;
+}
+/**
+ * Consent prompt data structure stored in additionalData.consent_prompt.
+ *
+ * @experimental This interface may change in future versions
+ */
+export interface ConsentPromptData {
+    /** Array of consent purposes requiring user review */
+    purposes: ConsentPurposeData[];
+}
+/**
+ * Extended request configuration for ThunderID V2 embedded flow operations.
+ *
+ * This interface extends the base request configuration with V2-specific
+ * properties required for the enhanced embedded flow API. The authId parameter
+ * is particularly important for the V2 OAuth2 flow completion process.
+ *
+ * @template T The type of the payload data being sent with the request
+ *
+ * @example
+ * ```typescript
+ * const config: EmbeddedFlowExecuteRequestConfig = {
+ *   baseUrl: 'https://localhost:8090',
+ *   payload: {
+ *     flowType: 'AUTHENTICATION',
+ *     inputs: { username: 'user@example.com' }
+ *   },
+ *   authId: 'auth_12345', // V2-specific for OAuth completion
+ *   headers: {
+ *     'Authorization': 'Bearer token'
+ *   }
+ * };
+ * ```
+ *
+ * @experimental This configuration is part of the new ThunderID V2 platform
+ */
+export interface EmbeddedFlowExecuteRequestConfig<T = any> extends EmbeddedFlowExecuteRequestConfigBase<T> {
+    /**
+     * Authentication ID used for OAuth2 flow completion in V2 API.
      *
-     * This is typically a short, high-level description of the error.
-     * For more detailed information, refer to the `description` field.
+     * When the embedded flow completes successfully and returns an assertion,
+     * this authId is used to complete the OAuth2 authorization flow by calling
+     * the `/oauth2/auth/callback` endpoint. This enables seamless transition from
+     * embedded flow to traditional OAuth2 flow completion.
      *
-     * @example "Error while provisioning user."
+     * @example "auth_abc123def456"
      */
-    message: string;
+    authId?: string;
 }
 //# sourceMappingURL=embedded-flow.d.ts.map