@azure/msal-browser 4.13.1 → 4.14.0

package/src/custom_auth/get_account/interaction_client/CustomAuthSilentCacheClient.ts

@@ -0,0 +1,215 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { CustomAuthAuthority } from "../../core/CustomAuthAuthority.js";
+import { DefaultPackageInfo } from "../../CustomAuthConstants.js";
+import * as PublicApiId from "../../core/telemetry/PublicApiId.js";
+import { CustomAuthInteractionClientBase } from "../../core/interaction_client/CustomAuthInteractionClientBase.js";
+import {
+    AccountInfo,
+    ClientAuthError,
+    ClientAuthErrorCodes,
+    ClientConfiguration,
+    CommonSilentFlowRequest,
+    RefreshTokenClient,
+    ServerTelemetryManager,
+    SilentFlowClient,
+    UrlString,
+} from "@azure/msal-common/browser";
+import { AuthenticationResult } from "../../../response/AuthenticationResult.js";
+import { ClearCacheRequest } from "../../../request/ClearCacheRequest.js";
+import { ApiId } from "../../../utils/BrowserConstants.js";
+import { getCurrentUri } from "../../../utils/BrowserUtils.js";
+
+export class CustomAuthSilentCacheClient extends CustomAuthInteractionClientBase {
+    /**
+     * Acquires a token from the cache if it is not expired. Otherwise, makes a request to renew the token.
+     * If forceRresh is set to false, then looks up the access token in cache first.
+     *   If access token is expired or not found, then uses refresh token to get a new access token.
+     *   If no refresh token is found or it is expired, then throws error.
+     * If forceRefresh is set to true, then skips token cache lookup and fetches a new token using refresh token
+     *   If no refresh token is found or it is expired, then throws error.
+     * @param silentRequest The silent request object.
+     * @returns {Promise<AuthenticationResult>} The promise that resolves to an AuthenticationResult.
+     */
+    override async acquireToken(
+        silentRequest: CommonSilentFlowRequest
+    ): Promise<AuthenticationResult> {
+        const telemetryManager = this.initializeServerTelemetryManager(
+            PublicApiId.ACCOUNT_GET_ACCESS_TOKEN
+        );
+        const clientConfig = this.getCustomAuthClientConfiguration(
+            telemetryManager,
+            this.customAuthAuthority
+        );
+        const silentFlowClient = new SilentFlowClient(
+            clientConfig,
+            this.performanceClient
+        );
+
+        try {
+            this.logger.verbose(
+                "Starting silent flow to acquire token from cache",
+                this.correlationId
+            );
+
+            const result = await silentFlowClient.acquireCachedToken(
+                silentRequest
+            );
+
+            this.logger.verbose(
+                "Silent flow to acquire token from cache is completed and token is found",
+                this.correlationId
+            );
+
+            return result[0] as AuthenticationResult;
+        } catch (error) {
+            if (
+                error instanceof ClientAuthError &&
+                error.errorCode === ClientAuthErrorCodes.tokenRefreshRequired
+            ) {
+                this.logger.verbose(
+                    "Token refresh is required to acquire token silently",
+                    this.correlationId
+                );
+
+                const refreshTokenClient = new RefreshTokenClient(
+                    clientConfig,
+                    this.performanceClient
+                );
+
+                this.logger.verbose(
+                    "Starting refresh flow to refresh token",
+                    this.correlationId
+                );
+
+                const refreshTokenResult =
+                    await refreshTokenClient.acquireTokenByRefreshToken(
+                        silentRequest
+                    );
+
+                this.logger.verbose(
+                    "Refresh flow to refresh token is completed",
+                    this.correlationId
+                );
+
+                return refreshTokenResult as AuthenticationResult;
+            }
+
+            throw error;
+        }
+    }
+
+    override async logout(logoutRequest?: ClearCacheRequest): Promise<void> {
+        const validLogoutRequest = this.initializeLogoutRequest(logoutRequest);
+
+        // Clear the cache
+        this.logger.verbose(
+            "Start to clear the cache",
+            logoutRequest?.correlationId
+        );
+        await this.clearCacheOnLogout(
+            validLogoutRequest.correlationId,
+            validLogoutRequest?.account
+        );
+        this.logger.verbose("Cache cleared", logoutRequest?.correlationId);
+
+        const postLogoutRedirectUri = this.config.auth.postLogoutRedirectUri;
+
+        if (postLogoutRedirectUri) {
+            const absoluteRedirectUri = UrlString.getAbsoluteUrl(
+                postLogoutRedirectUri,
+                getCurrentUri()
+            );
+
+            this.logger.verbose(
+                "Post logout redirect uri is set, redirecting to uri",
+                logoutRequest?.correlationId
+            );
+
+            // Redirect to post logout redirect uri
+            await this.navigationClient.navigateExternal(absoluteRedirectUri, {
+                apiId: ApiId.logout,
+                timeout: this.config.system.redirectNavigationTimeout,
+                noHistory: false,
+            });
+        }
+    }
+
+    getCurrentAccount(correlationId: string): AccountInfo | null {
+        let account: AccountInfo | null = null;
+
+        this.logger.verbose(
+            "Getting the first account from cache.",
+            correlationId
+        );
+
+        const allAccounts = this.browserStorage.getAllAccounts(
+            {},
+            correlationId
+        );
+
+        if (allAccounts.length > 0) {
+            if (allAccounts.length !== 1) {
+                this.logger.warning(
+                    "Multiple accounts found in cache. This is not supported in the Native Auth scenario.",
+                    correlationId
+                );
+            }
+
+            account = allAccounts[0];
+        }
+
+        if (account) {
+            this.logger.verbose("Account data found.", correlationId);
+        } else {
+            this.logger.verbose("No account data found.", correlationId);
+        }
+
+        return account;
+    }
+
+    private getCustomAuthClientConfiguration(
+        serverTelemetryManager: ServerTelemetryManager,
+        customAuthAuthority: CustomAuthAuthority
+    ): ClientConfiguration {
+        const logger = this.config.system.loggerOptions;
+
+        return {
+            authOptions: {
+                clientId: this.config.auth.clientId,
+                authority: customAuthAuthority,
+                clientCapabilities: this.config.auth.clientCapabilities,
+                redirectUri: this.config.auth.redirectUri,
+            },
+            systemOptions: {
+                tokenRenewalOffsetSeconds:
+                    this.config.system.tokenRenewalOffsetSeconds,
+                preventCorsPreflight: true,
+            },
+            loggerOptions: {
+                loggerCallback: logger.loggerCallback,
+                piiLoggingEnabled: logger.piiLoggingEnabled,
+                logLevel: logger.logLevel,
+                correlationId: this.correlationId,
+            },
+            cacheOptions: {
+                claimsBasedCachingEnabled:
+                    this.config.cache.claimsBasedCachingEnabled,
+            },
+            cryptoInterface: this.browserCrypto,
+            networkInterface: this.networkClient,
+            storageInterface: this.browserStorage,
+            serverTelemetryManager: serverTelemetryManager,
+            libraryInfo: {
+                sku: DefaultPackageInfo.SKU,
+                version: DefaultPackageInfo.VERSION,
+                cpu: DefaultPackageInfo.CPU,
+                os: DefaultPackageInfo.OS,
+            },
+            telemetry: this.config.telemetry,
+        };
+    }
+}

package/src/custom_auth/index.ts

@@ -0,0 +1,185 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+/**
+ * @packageDocumentation
+ * @module @azure/msal-browser/custom-auth
+ */
+
+/**
+ * This file is the entrypoint when importing with the custom-auth subpath e.g. "import { someExport } from @azure/msal-browser/custom-auth"
+ *  Additional exports should be added to the applicable exports-*.ts files
+ */
+
+// Application and Controller
+export { CustomAuthPublicClientApplication } from "./CustomAuthPublicClientApplication.js";
+export { ICustomAuthPublicClientApplication } from "./ICustomAuthPublicClientApplication.js";
+
+// Configuration
+export { CustomAuthConfiguration } from "./configuration/CustomAuthConfiguration.js";
+
+// Account Data
+export { CustomAuthAccountData } from "./get_account/auth_flow/CustomAuthAccountData.js";
+
+// Operation Inputs
+export {
+    SignInInputs,
+    SignUpInputs,
+    ResetPasswordInputs,
+    AccountRetrievalInputs,
+    AccessTokenRetrievalInputs,
+    SignInWithContinuationTokenInputs,
+} from "./CustomAuthActionInputs.js";
+
+// Operation Base State
+export { AuthFlowStateBase } from "./core/auth_flow/AuthFlowState.js";
+export { AuthFlowActionRequiredStateBase } from "./core/auth_flow/AuthFlowState.js";
+
+// Sign-in State
+export { SignInState } from "./sign_in/auth_flow/state/SignInState.js";
+export { SignInCodeRequiredState } from "./sign_in/auth_flow/state/SignInCodeRequiredState.js";
+export { SignInContinuationState } from "./sign_in/auth_flow/state/SignInContinuationState.js";
+export { SignInPasswordRequiredState } from "./sign_in/auth_flow/state/SignInPasswordRequiredState.js";
+export { SignInCompletedState } from "./sign_in/auth_flow/state/SignInCompletedState.js";
+export { SignInFailedState } from "./sign_in/auth_flow/state/SignInFailedState.js";
+
+// Sign-in Results
+export {
+    SignInResult,
+    SignInResultState,
+} from "./sign_in/auth_flow/result/SignInResult.js";
+export { SignInSubmitCodeResult } from "./sign_in/auth_flow/result/SignInSubmitCodeResult.js";
+export {
+    SignInResendCodeResult,
+    SignInResendCodeResultState,
+} from "./sign_in/auth_flow/result/SignInResendCodeResult.js";
+export { SignInSubmitPasswordResult } from "./sign_in/auth_flow/result/SignInSubmitPasswordResult.js";
+export { SignInSubmitCredentialResultState } from "./sign_in/auth_flow/result/SignInSubmitCredentialResult.js";
+
+// Sign-in Errors
+export {
+    SignInError,
+    SignInSubmitPasswordError,
+    SignInSubmitCodeError,
+    SignInResendCodeError,
+} from "./sign_in/auth_flow/error_type/SignInError.js";
+
+// Sign-up User Account Attributes
+export { UserAccountAttributes } from "./UserAccountAttributes.js";
+
+// Sign-up State
+export { SignUpState } from "./sign_up/auth_flow/state/SignUpState.js";
+export { SignUpAttributesRequiredState } from "./sign_up/auth_flow/state/SignUpAttributesRequiredState.js";
+export { SignUpCodeRequiredState } from "./sign_up/auth_flow/state/SignUpCodeRequiredState.js";
+export { SignUpPasswordRequiredState } from "./sign_up/auth_flow/state/SignUpPasswordRequiredState.js";
+export { SignUpCompletedState } from "./sign_up/auth_flow/state/SignUpCompletedState.js";
+export { SignUpFailedState } from "./sign_up/auth_flow/state/SignUpFailedState.js";
+
+// Sign-up Results
+export {
+    SignUpResult,
+    SignUpResultState,
+} from "./sign_up/auth_flow/result/SignUpResult.js";
+export {
+    SignUpSubmitAttributesResult,
+    SignUpSubmitAttributesResultState,
+} from "./sign_up/auth_flow/result/SignUpSubmitAttributesResult.js";
+export {
+    SignUpSubmitCodeResult,
+    SignUpSubmitCodeResultState,
+} from "./sign_up/auth_flow/result/SignUpSubmitCodeResult.js";
+export {
+    SignUpResendCodeResult,
+    SignUpResendCodeResultState,
+} from "./sign_up/auth_flow/result/SignUpResendCodeResult.js";
+export {
+    SignUpSubmitPasswordResult,
+    SignUpSubmitPasswordResultState,
+} from "./sign_up/auth_flow/result/SignUpSubmitPasswordResult.js";
+
+// Sign-up Errors
+export {
+    SignUpError,
+    SignUpSubmitPasswordError,
+    SignUpSubmitCodeError,
+    SignUpSubmitAttributesError,
+    SignUpResendCodeError,
+} from "./sign_up/auth_flow/error_type/SignUpError.js";
+
+// Reset-password State
+export { ResetPasswordState } from "./reset_password/auth_flow/state/ResetPasswordState.js";
+export { ResetPasswordCodeRequiredState } from "./reset_password/auth_flow/state/ResetPasswordCodeRequiredState.js";
+export { ResetPasswordPasswordRequiredState } from "./reset_password/auth_flow/state/ResetPasswordPasswordRequiredState.js";
+export { ResetPasswordCompletedState } from "./reset_password/auth_flow/state/ResetPasswordCompletedState.js";
+export { ResetPasswordFailedState } from "./reset_password/auth_flow/state/ResetPasswordFailedState.js";
+
+// Reset-password Results
+export {
+    ResetPasswordStartResult,
+    ResetPasswordStartResultState,
+} from "./reset_password/auth_flow/result/ResetPasswordStartResult.js";
+export {
+    ResetPasswordSubmitCodeResult,
+    ResetPasswordSubmitCodeResultState,
+} from "./reset_password/auth_flow/result/ResetPasswordSubmitCodeResult.js";
+export {
+    ResetPasswordResendCodeResult,
+    ResetPasswordResendCodeResultState,
+} from "./reset_password/auth_flow/result/ResetPasswordResendCodeResult.js";
+export {
+    ResetPasswordSubmitPasswordResult,
+    ResetPasswordSubmitPasswordResultState,
+} from "./reset_password/auth_flow/result/ResetPasswordSubmitPasswordResult.js";
+
+// Reset-password Errors
+export {
+    ResetPasswordError,
+    ResetPasswordSubmitPasswordError,
+    ResetPasswordSubmitCodeError,
+    ResetPasswordResendCodeError,
+} from "./reset_password/auth_flow/error_type/ResetPasswordError.js";
+
+// Get Access Token Results
+export {
+    GetAccessTokenResult,
+    GetAccessTokenResultState,
+} from "./get_account/auth_flow/result/GetAccessTokenResult.js";
+
+// Get Account Results
+export {
+    GetAccountResult,
+    GetAccountResultState,
+} from "./get_account/auth_flow/result/GetAccountResult.js";
+
+// Sign Out Results
+export {
+    SignOutResult,
+    SignOutResultState,
+} from "./get_account/auth_flow/result/SignOutResult.js";
+
+// Token Management Errors
+export {
+    GetAccountError,
+    SignOutError,
+    GetCurrentAccountAccessTokenError,
+} from "./get_account/auth_flow/error_type/GetAccountError.js";
+
+// Errors
+export { CustomAuthApiError } from "./core/error/CustomAuthApiError.js";
+export { CustomAuthError } from "./core/error/CustomAuthError.js";
+export { HttpError } from "./core/error/HttpError.js";
+export { InvalidArgumentError } from "./core/error/InvalidArgumentError.js";
+export { InvalidConfigurationError } from "./core/error/InvalidConfigurationError.js";
+export { MethodNotImplementedError } from "./core/error/MethodNotImplementedError.js";
+export { MsalCustomAuthError } from "./core/error/MsalCustomAuthError.js";
+export { NoCachedAccountFoundError } from "./core/error/NoCachedAccountFoundError.js";
+export { ParsedUrlError } from "./core/error/ParsedUrlError.js";
+export { UnexpectedError } from "./core/error/UnexpectedError.js";
+export { UnsupportedEnvironmentError } from "./core/error/UnsupportedEnvironmentError.js";
+export { UserAccountAttributeError } from "./core/error/UserAccountAttributeError.js";
+export { UserAlreadySignedInError } from "./core/error/UserAlreadySignedInError.js";
+
+// Components from msal_browser
+export { LogLevel } from "@azure/msal-common/browser";

package/src/custom_auth/operating_context/CustomAuthOperatingContext.ts

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { BaseOperatingContext } from "../../operatingcontext/BaseOperatingContext.js";
+import {
+    CustomAuthBrowserConfiguration,
+    CustomAuthConfiguration,
+    CustomAuthOptions,
+} from "../configuration/CustomAuthConfiguration.js";
+
+export class CustomAuthOperatingContext extends BaseOperatingContext {
+    private readonly customAuthOptions: CustomAuthOptions;
+    private static readonly MODULE_NAME: string = "";
+    private static readonly ID: string = "CustomAuthOperatingContext";
+
+    constructor(configuration: CustomAuthConfiguration) {
+        super(configuration);
+
+        this.customAuthOptions = configuration.customAuth;
+    }
+
+    getModuleName(): string {
+        return CustomAuthOperatingContext.MODULE_NAME;
+    }
+
+    getId(): string {
+        return CustomAuthOperatingContext.ID;
+    }
+
+    getCustomAuthConfig(): CustomAuthBrowserConfiguration {
+        return {
+            ...this.getConfig(),
+            customAuth: this.customAuthOptions,
+        };
+    }
+
+    async initialize(): Promise<boolean> {
+        this.available = typeof window !== "undefined";
+        return this.available;
+    }
+}

package/src/custom_auth/reset_password/auth_flow/error_type/ResetPasswordError.ts

@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { AuthActionErrorBase } from "../../../core/auth_flow/AuthFlowErrorBase.js";
+import { CustomAuthApiError } from "../../../core/error/CustomAuthApiError.js";
+import * as CustomAuthApiErrorCode from "../../../core/network_client/custom_auth_api/types/ApiErrorCodes.js";
+
+export class ResetPasswordError extends AuthActionErrorBase {
+    /**
+     * Checks if the error is due to the user not being found.
+     * @returns true if the error is due to the user not being found, false otherwise.
+     */
+    isUserNotFound(): boolean {
+        return this.isUserNotFoundError();
+    }
+
+    /**
+     * Checks if the error is due to the username being invalid.
+     * @returns true if the error is due to the username being invalid, false otherwise.
+     */
+    isInvalidUsername(): boolean {
+        return this.isUserInvalidError();
+    }
+
+    /**
+     * Checks if the error is due to the provided challenge type is not supported.
+     * @returns {boolean} True if the error is due to the provided challenge type is not supported, false otherwise.
+     */
+    isUnsupportedChallengeType(): boolean {
+        return this.isUnsupportedChallengeTypeError();
+    }
+
+    /**
+     * Check if client app supports the challenge type configured in Entra.
+     * @returns {boolean} True if client app doesn't support the challenge type configured in Entra, "loginPopup" function is required to continue the operation.
+     */
+    isRedirectRequired(): boolean {
+        return this.isRedirectError();
+    }
+}
+
+export class ResetPasswordSubmitPasswordError extends AuthActionErrorBase {
+    /**
+     * Checks if the new password is invalid or incorrect.
+     * @returns {boolean} True if the new password is invalid, false otherwise.
+     */
+    isInvalidPassword(): boolean {
+        return (
+            this.isInvalidNewPasswordError() || this.isPasswordIncorrectError()
+        );
+    }
+
+    /**
+     * Checks if the password reset failed due to reset timeout or password change failed.
+     * @returns {boolean} True if the password reset failed, false otherwise.
+     */
+    isPasswordResetFailed(): boolean {
+        return (
+            this.errorData instanceof CustomAuthApiError &&
+            (this.errorData.error ===
+                CustomAuthApiErrorCode.PASSWORD_RESET_TIMEOUT ||
+                this.errorData.error ===
+                    CustomAuthApiErrorCode.PASSWORD_CHANGE_FAILED)
+        );
+    }
+}
+
+export class ResetPasswordSubmitCodeError extends AuthActionErrorBase {
+    /**
+     * Checks if the provided code is invalid.
+     * @returns {boolean} True if the provided code is invalid, false otherwise.
+     */
+    isInvalidCode(): boolean {
+        return this.isInvalidCodeError();
+    }
+
+    /**
+     * Check if client app supports the challenge type configured in Entra.
+     * @returns {boolean} True if client app doesn't support the challenge type configured in Entra, "loginPopup" function is required to continue the operation.
+     */
+    isRedirectRequired(): boolean {
+        return this.isRedirectError();
+    }
+}
+
+export class ResetPasswordResendCodeError extends AuthActionErrorBase {
+    /**
+     * Check if client app supports the challenge type configured in Entra.
+     * @returns {boolean} True if client app doesn't support the challenge type configured in Entra, "loginPopup" function is required to continue the operation.
+     */
+    isRedirectRequired(): boolean {
+        return this.isRedirectError();
+    }
+}

package/src/custom_auth/reset_password/auth_flow/result/ResetPasswordResendCodeResult.ts

@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { AuthFlowResultBase } from "../../../core/auth_flow/AuthFlowResultBase.js";
+import { ResetPasswordResendCodeError } from "../error_type/ResetPasswordError.js";
+import type { ResetPasswordCodeRequiredState } from "../state/ResetPasswordCodeRequiredState.js";
+import { ResetPasswordFailedState } from "../state/ResetPasswordFailedState.js";
+
+/*
+ * Result of resending code in a reset password operation.
+ */
+export class ResetPasswordResendCodeResult extends AuthFlowResultBase<
+    ResetPasswordResendCodeResultState,
+    ResetPasswordResendCodeError,
+    void
+> {
+    /**
+     * Creates a new instance of ResetPasswordResendCodeResult.
+     * @param state The state of the result.
+     */
+    constructor(state: ResetPasswordResendCodeResultState) {
+        super(state);
+    }
+
+    /**
+     * Creates a new instance of ResetPasswordResendCodeResult with an error.
+     * @param error The error that occurred.
+     * @returns {ResetPasswordResendCodeResult} A new instance of ResetPasswordResendCodeResult with the error set.
+     */
+    static createWithError(error: unknown): ResetPasswordResendCodeResult {
+        const result = new ResetPasswordResendCodeResult(
+            new ResetPasswordFailedState()
+        );
+        result.error = new ResetPasswordResendCodeError(
+            ResetPasswordResendCodeResult.createErrorData(error)
+        );
+
+        return result;
+    }
+
+    /**
+     * Checks if the result is in a failed state.
+     */
+    isFailed(): this is ResetPasswordResendCodeResult & {
+        state: ResetPasswordFailedState;
+    } {
+        return this.state instanceof ResetPasswordFailedState;
+    }
+
+    /**
+     * Checks if the result is in a code required state.
+     */
+    isCodeRequired(): this is ResetPasswordResendCodeResult & {
+        state: ResetPasswordCodeRequiredState;
+    } {
+        /*
+         * The instanceof operator couldn't be used here to check the state type since the circular dependency issue.
+         * So we are using the constructor name to check the state type.
+         */
+        return (
+            this.state.constructor?.name === "ResetPasswordCodeRequiredState"
+        );
+    }
+}
+
+/**
+ * The possible states for the ResetPasswordResendCodeResult.
+ * This includes:
+ * - ResetPasswordCodeRequiredState: The reset password process requires a code.
+ * - ResetPasswordFailedState: The reset password process has failed.
+ */
+export type ResetPasswordResendCodeResultState =
+    | ResetPasswordCodeRequiredState
+    | ResetPasswordFailedState;

package/src/custom_auth/reset_password/auth_flow/result/ResetPasswordStartResult.ts

@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { AuthFlowResultBase } from "../../../core/auth_flow/AuthFlowResultBase.js";
+import { ResetPasswordError } from "../error_type/ResetPasswordError.js";
+import { ResetPasswordCodeRequiredState } from "../state/ResetPasswordCodeRequiredState.js";
+import { ResetPasswordFailedState } from "../state/ResetPasswordFailedState.js";
+
+/*
+ * Result of a reset password operation.
+ */
+export class ResetPasswordStartResult extends AuthFlowResultBase<
+    ResetPasswordStartResultState,
+    ResetPasswordError,
+    void
+> {
+    /**
+     * Creates a new instance of ResetPasswordStartResult.
+     * @param state The state of the result.
+     */
+    constructor(state: ResetPasswordStartResultState) {
+        super(state);
+    }
+
+    /**
+     * Creates a new instance of ResetPasswordStartResult with an error.
+     * @param error The error that occurred.
+     * @returns {ResetPasswordStartResult} A new instance of ResetPasswordStartResult with the error set.
+     */
+    static createWithError(error: unknown): ResetPasswordStartResult {
+        const result = new ResetPasswordStartResult(
+            new ResetPasswordFailedState()
+        );
+        result.error = new ResetPasswordError(
+            ResetPasswordStartResult.createErrorData(error)
+        );
+
+        return result;
+    }
+
+    /**
+     * Checks if the result is in a failed state.
+     */
+    isFailed(): this is ResetPasswordStartResult & {
+        state: ResetPasswordFailedState;
+    } {
+        return this.state instanceof ResetPasswordFailedState;
+    }
+
+    /**
+     * Checks if the result is in a code required state.
+     */
+    isCodeRequired(): this is ResetPasswordStartResult & {
+        state: ResetPasswordCodeRequiredState;
+    } {
+        return this.state instanceof ResetPasswordCodeRequiredState;
+    }
+}
+
+/**
+ * The possible states for the ResetPasswordStartResult.
+ * This includes:
+ * - ResetPasswordCodeRequiredState: The reset password process requires a code.
+ * - ResetPasswordFailedState: The reset password process has failed.
+ */
+export type ResetPasswordStartResultState =
+    | ResetPasswordCodeRequiredState
+    | ResetPasswordFailedState;