@thunderid/javascript 0.0.1

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

@@ -0,0 +1,340 @@
+/**
+ * Copyright (c) 2025, WSO2 LLC. (https://www.wso2.com).
+ *
+ * WSO2 LLC. licenses this file to you under the Apache License,
+ * Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { EmbeddedFlowResponseData as EmbeddedFlowResponseDataV2 } from './embedded-flow-v2';
+import { EmbeddedFlowResponseType as EmbeddedFlowResponseTypeV1, EmbeddedFlowType as EmbeddedFlowTypeV1 } from '../embedded-flow';
+/**
+ * Status enumeration for ThunderID embedded sign-in flow operations.
+ *
+ * These statuses indicate the current state of the sign-in flow and determine
+ * the next action required by the client application. Each status provides
+ * specific guidance on how to proceed with the authentication process.
+ *
+ * @example
+ * ```typescript
+ * switch (response.flowStatus) {
+ *   case EmbeddedSignInFlowStatus.Incomplete:
+ *     // More user input needed - render form components
+ *     break;
+ *   case EmbeddedSignInFlowStatus.Complete:
+ *     // Authentication successful - handle completion
+ *     break;
+ *   case EmbeddedSignInFlowStatus.Error:
+ *     // Authentication failed - show error message
+ *     break;
+ * }
+ * ```
+ *
+ * @experimental Part of the new ThunderID API
+ */
+export declare enum EmbeddedSignInFlowStatus {
+    /**
+     * Sign-in flow completed successfully.
+     *
+     * The user has been authenticated and the flow can proceed to
+     * OAuth2 completion or redirection. Check for redirectUrl or
+     * assertion data in the response.
+     */
+    Complete = "COMPLETE",
+    /**
+     * Sign-in flow encountered an error.
+     *
+     * Authentication failed due to invalid credentials, system error,
+     * or other issues. Check error details in the response and handle
+     * appropriately (retry, show error message, etc.).
+     */
+    Error = "ERROR",
+    /**
+     * Sign-in flow requires additional user input.
+     *
+     * More authentication steps are needed. The response will contain
+     * components in data.meta.components that should be rendered to
+     * collect additional user input (e.g., MFA, password, etc.).
+     */
+    Incomplete = "INCOMPLETE"
+}
+/**
+ * Type enumeration for ThunderID embedded sign-in flow responses.
+ *
+ * Determines the nature of the flow response and how the client should
+ * handle the returned data. This affects both UI rendering and flow
+ * continuation logic.
+ *
+ * @experimental Part of the new ThunderID API
+ */
+export declare enum EmbeddedSignInFlowType {
+    /**
+     * Response requires external redirection.
+     *
+     * Used for social login providers, external identity providers,
+     * or other flows that require navigating to an external URL.
+     * The response will contain redirection information.
+     */
+    Redirection = "REDIRECTION",
+    /**
+     * Response contains view components for rendering.
+     *
+     * Standard embedded flow response containing UI components
+     * that should be rendered within the current application
+     * context. Most common type for embedded authentication.
+     */
+    View = "VIEW"
+}
+/**
+ * Extended response structure for ThunderID embedded sign-in flow.
+ *
+ * This interface defines additional properties that are added at the SDK level
+ * to enhance the basic API response with client-side computed values. These
+ * properties provide convenience for common post-authentication operations.
+ *
+ * @remarks This response structure is enhanced by the SDK and contains
+ * properties beyond the raw API response. It's designed to simplify
+ * post-authentication handling for client applications.
+ *
+ * @experimental This interface is part of the new ThunderID platform
+ */
+export interface ExtendedEmbeddedSignInFlowResponse {
+    /**
+     * Computed redirect URL for post-authentication navigation.
+     *
+     * This URL is determined by the SDK based on the flow completion result
+     * and configured redirect settings. When present, the client application
+     * should navigate to this URL to complete the authentication process.
+     *
+     * @example "https://myapp.com/dashboard?session=abc123"
+     */
+    redirectUrl?: string;
+}
+/**
+ * Primary response structure for ThunderID embedded sign-in flow operations.
+ *
+ * This is the main response interface returned by the sign-in API, combining
+ * the enhanced SDK properties with the core API response data. It provides all
+ * information needed to handle the current state of the authentication flow.
+ *
+ * The response structure adapts based on the flow status:
+ * - INCOMPLETE: Contains components for user interaction
+ * - COMPLETE: Contains completion data and potential redirection info
+ * - ERROR: Contains error information for troubleshooting
+ *
+ * @example
+ * ```typescript
+ * const response: EmbeddedSignInFlowResponse = {
+ *   executionId: "flow_12345",
+ *   flowStatus: EmbeddedSignInFlowStatus.Incomplete,
+ *   type: EmbeddedSignInFlowType.View,
+ *   data: {
+ *     meta: {
+ *       components: [
+ *         {
+ *           id: "username_field",
+ *           type: EmbeddedFlowComponentType.TextInput,
+ *           label: "Username",
+ *           required: true
+ *         }
+ *       ]
+ *     }
+ *   }
+ * };
+ * ```
+ *
+ * @experimental This interface is part of the new ThunderID platform
+ */
+export interface EmbeddedSignInFlowResponse extends ExtendedEmbeddedSignInFlowResponse {
+    /**
+     * JWT assertion returned when the flow reaches COMPLETE status on the V2 platform.
+     * Used to establish the session without a separate OAuth2 redirect.
+     */
+    assertion?: string;
+    /**
+     * Per-step challenge token for replay protection.
+     * Must be included in the next request to continue this flow.
+     */
+    challengeToken?: string;
+    /**
+     * Core response data containing UI components and flow metadata.
+     * Includes both modern meta.components structure and legacy fields for compatibility.
+     */
+    data: EmbeddedFlowResponseDataV2 & {
+        /**
+         * Legacy action definitions for backward compatibility.
+         * @deprecated Use data.meta.components for new implementations
+         */
+        actions?: {
+            /** Unique action identifier */
+            id: string;
+            /** Action type identifier */
+            type: EmbeddedFlowResponseTypeV1;
+        }[];
+        /**
+         * Legacy input field definitions for backward compatibility.
+         * @deprecated Use data.meta.components for new implementations
+         */
+        inputs?: {
+            /** Field name identifier */
+            name: string;
+            /** Whether the field is required */
+            required: boolean;
+            /** Input field type */
+            type: string;
+        }[];
+    };
+    /**
+     * Unique identifier for this specific flow instance.
+     * Used to maintain state across multiple API calls during the authentication process.
+     */
+    executionId: string;
+    /**
+     * Optional reason for flow failure in case of an error.
+     * Provides additional context when flowStatus is set to ERROR.
+     */
+    failureReason?: string;
+    /**
+     * Current status of the sign-in flow.
+     * Determines the next action required by the client application.
+     */
+    flowStatus: EmbeddedSignInFlowStatus;
+    /**
+     * Type of response indicating how to handle the returned data.
+     * Affects both UI rendering and navigation logic.
+     */
+    type: EmbeddedSignInFlowType;
+}
+/**
+ * Response structure for completed ThunderID embedded sign-in flows.
+ *
+ * This interface defines the response format when the embedded sign-in flow
+ * reaches the COMPLETE status and requires OAuth2 flow completion. It contains
+ * the redirect URI that should be used for the final authentication step.
+ *
+ * @example
+ * ```typescript
+ * const completeResponse: EmbeddedSignInFlowCompleteResponse = {
+ *   redirect_uri: "https://myapp.com/callback?code=abc123&state=xyz789"
+ * };
+ *
+ * // Typically handled automatically by the SDK
+ * window.location.href = completeResponse.redirect_uri;
+ * ```
+ *
+ * @experimental This interface is part of the new ThunderID platform
+ */
+export interface EmbeddedSignInFlowCompleteResponse {
+    /**
+     * OAuth2 redirect URI for completing the authentication flow.
+     *
+     * Contains the final redirect URL with authorization code, state,
+     * and other OAuth2 parameters needed to complete the authentication
+     * process. This URL should be navigated to automatically or manually
+     * depending on the application's requirements.
+     */
+    redirect_uri: string;
+}
+/**
+ * Request payload for initiating ThunderID embedded sign-in flows.
+ *
+ * This type defines the minimum required information to start a new
+ * embedded sign-in flow. The flow type determines the kind of authentication
+ * process that will be initiated (e.g., standard login, MFA, etc.).
+ *
+ * @example
+ * ```typescript
+ * const initRequest: EmbeddedSignInFlowInitiateRequest = {
+ *   applicationId: "app_12345",
+ *   flowType: EmbeddedFlowType.Authentication
+ * };
+ *
+ * const response = await executeEmbeddedSignInFlow({
+ *   baseUrl: "https://api.asgardeo.io/t/myorg",
+ *   payload: initRequest
+ * });
+ * ```
+ *
+ * @experimental This type is part of the new ThunderID platform
+ */
+export interface EmbeddedSignInFlowInitiateRequest {
+    /**
+     * Unique identifier of the application initiating the sign-in flow.
+     * Must be a valid application ID registered in the ThunderID organization.
+     */
+    applicationId: string;
+    /**
+     * Type of embedded flow to initiate.
+     * Determines the authentication process and available options.
+     */
+    flowType: EmbeddedFlowTypeV1;
+}
+/**
+ * Request payload for executing steps in ThunderID embedded sign-in flows.
+ *
+ * This interface defines the structure for subsequent requests after flow initiation.
+ * It supports both continuing existing flows (with executionId) and submitting user
+ * input data collected from the rendered components.
+ *
+ * @example
+ * ```typescript
+ * // Continue existing flow with user input
+ * const stepRequest: EmbeddedSignInFlowRequest = {
+ *   executionId: "flow_12345",
+ *   action: "action_001",
+ *   inputs: {
+ *     username: "user@example.com",
+ *     password: "securePassword123"
+ *   }
+ * };
+ *
+ * // Submit to continue the flow
+ * const response = await executeEmbeddedSignInFlow({
+ *   baseUrl: "https://api.asgardeo.io/t/myorg",
+ *   payload: stepRequest
+ * });
+ * ```
+ *
+ * @experimental This interface is part of the new ThunderID platform
+ */
+export interface EmbeddedSignInFlowRequest extends Partial<EmbeddedSignInFlowInitiateRequest> {
+    /**
+     * Identifier of the specific action being triggered.
+     * Corresponds to action components in the UI (e.g., submit button, social login).
+     */
+    action?: string;
+    /**
+     * Per-step challenge token received from the previous flow response.
+     * Required when continuing an existing flow to prevent replay attacks.
+     */
+    challengeToken?: string;
+    /**
+     * Identifier of the flow instance to continue.
+     * Required when submitting data for an existing flow.
+     */
+    executionId?: string;
+    /**
+     * User input data collected from the form components.
+     * Keys should match the component identifiers from the response.
+     *
+     * @example
+     * ```typescript
+     * {
+     *   "username": "john.doe@example.com",
+     *   "password": "mySecurePassword",
+     *   "rememberMe": true
+     * }
+     * ```
+     */
+    inputs?: Record<string, any>;
+}
+//# sourceMappingURL=embedded-signin-flow-v2.d.ts.map

package/dist/models/v2/embedded-signin-flow-v2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embedded-signin-flow-v2.d.ts","sourceRoot":"","sources":["../../../src/models/v2/embedded-signin-flow-v2.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAC,wBAAwB,IAAI,0BAA0B,EAAC,MAAM,oBAAoB,CAAC;AAC1F,OAAO,EACL,wBAAwB,IAAI,0BAA0B,EACtD,gBAAgB,IAAI,kBAAkB,EACvC,MAAM,kBAAkB,CAAC;AAE1B;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,oBAAY,wBAAwB;IAClC;;;;;;OAMG;IACH,QAAQ,aAAa;IAErB;;;;;;OAMG;IACH,KAAK,UAAU;IAEf;;;;;;OAMG;IACH,UAAU,eAAe;CAC1B;AAED;;;;;;;;GAQG;AACH,oBAAY,sBAAsB;IAChC;;;;;;OAMG;IACH,WAAW,gBAAgB;IAE3B;;;;;;OAMG;IACH,IAAI,SAAS;CACd;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,kCAAkC;IACjD;;;;;;;;OAQG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,WAAW,0BAA2B,SAAQ,kCAAkC;IACpF;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB;;;OAGG;IACH,IAAI,EAAE,0BAA0B,GAAG;QACjC;;;WAGG;QACH,OAAO,CAAC,EAAE;YACR,+BAA+B;YAC/B,EAAE,EAAE,MAAM,CAAC;YACX,6BAA6B;YAC7B,IAAI,EAAE,0BAA0B,CAAC;SAClC,EAAE,CAAC;QAEJ;;;WAGG;QACH,MAAM,CAAC,EAAE;YACP,4BAA4B;YAC5B,IAAI,EAAE,MAAM,CAAC;YACb,oCAAoC;YACpC,QAAQ,EAAE,OAAO,CAAC;YAClB,uBAAuB;YACvB,IAAI,EAAE,MAAM,CAAC;SACd,EAAE,CAAC;KACL,CAAC;IAEF;;;OAGG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB;;;OAGG;IACH,UAAU,EAAE,wBAAwB,CAAC;IAErC;;;OAGG;IACH,IAAI,EAAE,sBAAsB,CAAC;CAC9B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,kCAAkC;IACjD;;;;;;;OAOG;IACH,YAAY,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,WAAW,iCAAiC;IAChD;;;OAGG;IACH,aAAa,EAAE,MAAM,CAAC;IAEtB;;;OAGG;IACH,QAAQ,EAAE,kBAAkB,CAAC;CAC9B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,WAAW,yBAA0B,SAAQ,OAAO,CAAC,iCAAiC,CAAC;IAC3F;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC9B"}

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

@@ -0,0 +1,272 @@
+/**
+ * Copyright (c) 2025, WSO2 LLC. (https://www.wso2.com).
+ *
+ * WSO2 LLC. licenses this file to you under the Apache License,
+ * Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { EmbeddedFlowResponseType as EmbeddedFlowResponseTypeV1, EmbeddedFlowType as EmbeddedFlowTypeV1 } from '../embedded-flow';
+/**
+ * Status enumeration for ThunderID embedded sign-up flow operations.
+ *
+ * These statuses indicate the current state of the registration flow and determine
+ * the next action required by the client application. Each status provides specific
+ * guidance on how to proceed with the user registration process.
+ *
+ * @example
+ * ```typescript
+ * switch (response.flowStatus) {
+ *   case EmbeddedSignUpFlowStatus.Incomplete:
+ *     // More user input needed - render registration form components
+ *     break;
+ *   case EmbeddedSignUpFlowStatus.Complete:
+ *     // Registration successful - handle completion
+ *     break;
+ *   case EmbeddedSignUpFlowStatus.Error:
+ *     // Registration failed - show detailed error message
+ *     const errorResponse = response as EmbeddedSignUpFlowErrorResponse;
+ *     showError(errorResponse.failureReason);
+ *     break;
+ * }
+ * ```
+ *
+ * @experimental Part of the new ThunderID API
+ */
+export declare enum EmbeddedSignUpFlowStatus {
+    /**
+     * Sign-up flow completed successfully.
+     *
+     * The user has successfully registered and the flow can proceed to
+     * OAuth2 completion or redirection. Check for redirectUrl or assertion
+     * data in the response for next steps.
+     */
+    Complete = "COMPLETE",
+    /**
+     * Sign-up flow encountered an error and cannot proceed.
+     *
+     * Registration failed due to validation errors, duplicate user,
+     * system errors, or other issues. The response will be of type
+     * `EmbeddedSignUpFlowErrorResponse` containing detailed failure
+     * information that can be displayed to the user.
+     *
+     * @see {@link EmbeddedSignUpFlowErrorResponse} for error response structure
+     */
+    Error = "ERROR",
+    /**
+     * Sign-up flow requires additional user input.
+     *
+     * More registration steps are needed. The response will contain
+     * components in data.meta.components that should be rendered to
+     * collect additional user information (e.g., profile data, verification).
+     */
+    Incomplete = "INCOMPLETE"
+}
+/**
+ * Type enumeration for ThunderID embedded sign-up flow responses.
+ *
+ * Determines the nature of the registration flow response and how the client
+ * should handle the returned data. This affects both UI rendering and flow
+ * continuation logic during the user registration process.
+ *
+ * @experimental Part of the new ThunderID API
+ */
+export declare enum EmbeddedSignUpFlowType {
+    /**
+     * Response requires external redirection.
+     *
+     * Used for social registration providers, external identity providers,
+     * or other flows that require navigating to an external URL during
+     * the registration process. The response will contain redirection information.
+     */
+    Redirection = "REDIRECTION",
+    /**
+     * Response contains view components for rendering.
+     *
+     * Standard embedded registration flow response containing UI components
+     * that should be rendered within the current application context.
+     * Most common type for embedded user registration.
+     */
+    View = "VIEW"
+}
+/**
+ * Extended response structure for the embedded sign-up flow.
+ * @remarks This response is only done from the SDK level.
+ * @experimental
+ */
+export interface ExtendedEmbeddedSignUpFlowResponse {
+    /**
+     * The URL to redirect the user after completing the sign-up flow.
+     */
+    redirectUrl?: string;
+}
+/**
+ * Response structure for the new ThunderID embedded sign-up flow.
+ *
+ * This interface defines the structure for successful sign-up flow responses
+ * from ThunderID APIs. For error responses, see `EmbeddedSignUpFlowErrorResponse`.
+ *
+ * **Flow States:**
+ * - `INCOMPLETE`: More user input required, `data` contains form components
+ * - `COMPLETE`: Sign-up finished, may contain redirect information
+ * - For `ERROR` status, a separate `EmbeddedSignUpFlowErrorResponse` structure is used
+ *
+ * **Component-Driven UI:**
+ * The `data.inputs` and `data.actions` are transformed by the React transformer
+ * into component-driven format for consistent UI rendering across different
+ * ThunderID versions.
+ *
+ * @experimental Part of the new ThunderID API
+ * @see {@link EmbeddedSignUpFlowErrorResponse} for error response structure
+ * @see {@link EmbeddedSignUpFlowStatus} for available flow statuses
+ */
+export interface EmbeddedSignUpFlowResponse extends ExtendedEmbeddedSignUpFlowResponse {
+    /**
+     * Per-step challenge token for replay protection.
+     * Must be included in the next request to continue this flow.
+     */
+    challengeToken?: string;
+    /**
+     * Flow data containing form inputs and available actions.
+     * This is transformed to component-driven format by the React transformer.
+     */
+    data: {
+        /**
+         * Available actions the user can take (e.g., form submission, social sign-up).
+         */
+        actions?: {
+            id: string;
+            type: EmbeddedFlowResponseTypeV1;
+        }[];
+        /**
+         * Input fields required for the current step of the sign-up flow.
+         */
+        inputs?: {
+            name: string;
+            required: boolean;
+            type: string;
+        }[];
+    };
+    /**
+     * Unique identifier for this sign-up flow instance.
+     */
+    executionId: string;
+    /**
+     * Optional reason for flow failure in case of an error.
+     * Provides additional context when flowStatus is set to ERROR.
+     */
+    failureReason?: string;
+    /**
+     * Current status of the sign-up flow.
+     * Determines whether more input is needed or the flow is complete.
+     */
+    flowStatus: EmbeddedSignUpFlowStatus;
+    /**
+     * Type of response, indicating the expected user interaction.
+     */
+    type: EmbeddedSignUpFlowType;
+}
+/**
+ * Response structure for the new ThunderID embedded sign-up flow when the flow is complete.
+ * @experimental
+ */
+export interface EmbeddedSignUpFlowCompleteResponse {
+    redirect_uri: string;
+}
+/**
+ * Request payload for initiating the new ThunderID embedded sign-up flow.
+ * @experimental
+ */
+export interface EmbeddedSignUpFlowInitiateRequest {
+    applicationId: string;
+    flowType: EmbeddedFlowTypeV1;
+}
+/**
+ * Request payload for executing steps in the new ThunderID embedded sign-up flow.
+ * @experimental
+ */
+export interface EmbeddedSignUpFlowRequest extends Partial<EmbeddedSignUpFlowInitiateRequest> {
+    action?: string;
+    challengeToken?: string;
+    executionId?: string;
+    inputs?: Record<string, any>;
+}
+/**
+ * Error response structure for the new ThunderID embedded sign-up flow.
+ *
+ * This interface defines the structure of error responses returned by ThunderID APIs
+ * when sign-up operations fail. Unlike ThunderIDV1 which uses generic error codes and
+ * descriptions, ThunderID provides more specific failure reasons within the flow context.
+ *
+ * **Key Differences from ThunderIDV1:**
+ * - Uses `failureReason` instead of `message`/`description` for error details
+ * - Maintains flow context with `executionId` for tracking failed operations
+ * - Uses structured `flowStatus` enum instead of generic error codes
+ * - Provides empty `data` object for consistency with success responses
+ *
+ * **Error Handling:**
+ * This error response format is automatically detected and processed by the
+ * `extractErrorMessage()` and `checkForErrorResponse()` functions in the transformer
+ * to extract meaningful error messages for display to users.
+ *
+ * @example
+ * ```typescript
+ * // Typical ThunderID error response
+ * const errorResponse: EmbeddedSignUpFlowErrorResponse = {
+ *   executionId: "0ccfeaf9-18b3-43a5-bcc1-07d863dcb2c0",
+ *   flowStatus: EmbeddedSignUpFlowStatus.Error,
+ *   data: {},
+ *   failureReason: "User already exists with the provided username."
+ * };
+ *
+ * // This will be automatically transformed to a user-friendly error message:
+ * // "User already exists with the provided username."
+ * ```
+ *
+ * @experimental This is part of the new ThunderID API and may change in future versions
+ * @see {@link EmbeddedSignUpFlowStatus.Error} for the error status enum value
+ * @see {@link EmbeddedSignUpFlowResponse} for the corresponding success response structure
+ */
+export interface EmbeddedSignUpFlowErrorResponse {
+    /**
+     * Additional response data, typically empty for error responses.
+     * Maintained for structural consistency with successful flow responses
+     * which contain components, actions, and other flow data.
+     */
+    data: Record<string, any>;
+    /**
+     * Human-readable explanation of why the sign-up operation failed.
+     *
+     * This field contains specific error details that can be directly displayed
+     * to users, such as:
+     * - "User already exists with the provided username."
+     * - "Invalid email address format."
+     * - "Password does not meet complexity requirements."
+     *
+     * Unlike generic error codes, this provides contextual information
+     * that helps users understand and resolve the issue.
+     */
+    /**
+     * Unique identifier for the sign-up flow instance.
+     * This ID is used to track the flow state and correlate error responses
+     * with the specific sign-up attempt that failed.
+     */
+    executionId: string;
+    failureReason: string;
+    /**
+     * Status of the sign-up flow, which will be `EmbeddedSignUpFlowStatus.Error`
+     * for error responses. This field is used by error detection logic to
+     * identify failed flow responses.
+     */
+    flowStatus: EmbeddedSignUpFlowStatus;
+}
+//# sourceMappingURL=embedded-signup-flow-v2.d.ts.map

package/dist/models/v2/embedded-signup-flow-v2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embedded-signup-flow-v2.d.ts","sourceRoot":"","sources":["../../../src/models/v2/embedded-signup-flow-v2.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EACL,wBAAwB,IAAI,0BAA0B,EACtD,gBAAgB,IAAI,kBAAkB,EACvC,MAAM,kBAAkB,CAAC;AAE1B;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,oBAAY,wBAAwB;IAClC;;;;;;OAMG;IACH,QAAQ,aAAa;IAErB;;;;;;;;;OASG;IACH,KAAK,UAAU;IAEf;;;;;;OAMG;IACH,UAAU,eAAe;CAC1B;AAED;;;;;;;;GAQG;AACH,oBAAY,sBAAsB;IAChC;;;;;;OAMG;IACH,WAAW,gBAAgB;IAE3B;;;;;;OAMG;IACH,IAAI,SAAS;CACd;AAED;;;;GAIG;AACH,MAAM,WAAW,kCAAkC;IACjD;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,0BAA2B,SAAQ,kCAAkC;IACpF;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB;;;OAGG;IACH,IAAI,EAAE;QACJ;;WAEG;QACH,OAAO,CAAC,EAAE;YACR,EAAE,EAAE,MAAM,CAAC;YACX,IAAI,EAAE,0BAA0B,CAAC;SAClC,EAAE,CAAC;QAEJ;;WAEG;QACH,MAAM,CAAC,EAAE;YACP,IAAI,EAAE,MAAM,CAAC;YACb,QAAQ,EAAE,OAAO,CAAC;YAClB,IAAI,EAAE,MAAM,CAAC;SACd,EAAE,CAAC;KACL,CAAC;IAEF;;OAEG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB;;;OAGG;IACH,UAAU,EAAE,wBAAwB,CAAC;IAErC;;OAEG;IACH,IAAI,EAAE,sBAAsB,CAAC;CAC9B;AAED;;;GAGG;AACH,MAAM,WAAW,kCAAkC;IACjD,YAAY,EAAE,MAAM,CAAC;CACtB;AAED;;;GAGG;AACH,MAAM,WAAW,iCAAiC;IAChD,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,kBAAkB,CAAC;CAC9B;AAED;;;GAGG;AACH,MAAM,WAAW,yBAA0B,SAAQ,OAAO,CAAC,iCAAiC,CAAC;IAC3F,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC9B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAM,WAAW,+BAA+B;IAC9C;;;;OAIG;IACH,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAE1B;;;;;;;;;;;OAWG;IACH;;;;OAIG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB,aAAa,EAAE,MAAM,CAAC;IAEtB;;;;OAIG;IACH,UAAU,EAAE,wBAAwB,CAAC;CACtC"}