@azure/msal-browser 4.23.0 → 4.24.1

package/src/custom_auth/core/auth_flow/mfa/state/MfaState.ts

@@ -0,0 +1,188 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import {
+    MfaAwaitingStateParameters,
+    MfaStateParameters,
+    MfaVerificationRequiredStateParameters,
+} from "./MfaStateParameters.js";
+import { MfaSubmitChallengeResult } from "../result/MfaSubmitChallengeResult.js";
+import { MfaRequestChallengeResult } from "../result/MfaRequestChallengeResult.js";
+import {
+    MfaSubmitChallengeParams,
+    MfaRequestChallengeParams,
+} from "../../../interaction_client/mfa/parameter/MfaClientParameters.js";
+import { CustomAuthAccountData } from "../../../../get_account/auth_flow/CustomAuthAccountData.js";
+import { MfaCompletedState } from "./MfaCompletedState.js";
+import { ensureArgumentIsNotEmptyString } from "../../../utils/ArgumentValidator.js";
+import { AuthenticationMethod } from "../../../network_client/custom_auth_api/types/ApiResponseTypes.js";
+import { AuthFlowActionRequiredStateBase } from "../../AuthFlowState.js";
+
+abstract class MfaState<
+    TParameters extends MfaStateParameters
+> extends AuthFlowActionRequiredStateBase<TParameters> {
+    /**
+     * Requests an MFA challenge for a specific authentication method.
+     * @param authMethodId The authentication method ID to use for the challenge.
+     * @returns Promise that resolves to MfaRequestChallengeResult.
+     * @warning This API is experimental. It may be changed in the future without notice. Do not use in production applications.
+     */
+    async requestChallenge(
+        authMethodId: string
+    ): Promise<MfaRequestChallengeResult> {
+        try {
+            ensureArgumentIsNotEmptyString("authMethodId", authMethodId);
+
+            this.stateParameters.logger.verbose(
+                `Requesting MFA challenge with authentication method - '${authMethodId}'.`,
+                this.stateParameters.correlationId
+            );
+
+            const requestParams: MfaRequestChallengeParams = {
+                correlationId: this.stateParameters.correlationId,
+                continuationToken: this.stateParameters.continuationToken ?? "",
+                challengeType:
+                    this.stateParameters.config.customAuth.challengeTypes ?? [],
+                authMethodId: authMethodId,
+            };
+
+            const result =
+                await this.stateParameters.mfaClient.requestChallenge(
+                    requestParams
+                );
+
+            this.stateParameters.logger.verbose(
+                "MFA challenge requested successfully.",
+                this.stateParameters.correlationId
+            );
+
+            return new MfaRequestChallengeResult(
+                new MfaVerificationRequiredState({
+                    correlationId: result.correlationId,
+                    continuationToken: result.continuationToken,
+                    config: this.stateParameters.config,
+                    logger: this.stateParameters.logger,
+                    mfaClient: this.stateParameters.mfaClient,
+                    cacheClient: this.stateParameters.cacheClient,
+                    challengeChannel: result.challengeChannel,
+                    challengeTargetLabel: result.challengeTargetLabel,
+                    codeLength: result.codeLength,
+                    selectedAuthMethodId: authMethodId,
+                    scopes: this.stateParameters.scopes ?? [],
+                })
+            );
+        } catch (error) {
+            this.stateParameters.logger.errorPii(
+                `Failed to request MFA challenge. Error: ${error}.`,
+                this.stateParameters.correlationId
+            );
+
+            return MfaRequestChallengeResult.createWithError(error);
+        }
+    }
+}
+
+/**
+ * State indicating that MFA is required and awaiting user action.
+ * This state allows the developer to pause execution before sending the code to the user's email.
+ */
+export class MfaAwaitingState extends MfaState<MfaAwaitingStateParameters> {
+    /**
+     * Gets the available authentication methods for MFA.
+     * @returns Array of available authentication methods.
+     * @warning This API is experimental. It may be changed in the future without notice. Do not use in production applications.
+     */
+    getAuthMethods(): AuthenticationMethod[] {
+        return this.stateParameters.authMethods;
+    }
+}
+
+/**
+ * State indicating that MFA verification is required.
+ * The challenge has been sent and the user needs to provide the code.
+ */
+export class MfaVerificationRequiredState extends MfaState<MfaVerificationRequiredStateParameters> {
+    /**
+     * Gets the length of the code that the user needs to provide.
+     * @returns The expected code length.
+     * @warning This API is experimental. It may be changed in the future without notice. Do not use in production applications.
+     */
+    getCodeLength(): number {
+        return this.stateParameters.codeLength;
+    }
+
+    /**
+     * Gets the channel through which the challenge was sent.
+     * @returns The challenge channel (e.g., "email").
+     * @warning This API is experimental. It may be changed in the future without notice. Do not use in production applications.
+     */
+    getChannel(): string {
+        return this.stateParameters.challengeChannel;
+    }
+
+    /**
+     * Gets the target label indicating where the challenge was sent.
+     * @returns The challenge target label (e.g., masked email address).
+     * @warning This API is experimental. It may be changed in the future without notice. Do not use in production applications.
+     */
+    getSentTo(): string {
+        return this.stateParameters.challengeTargetLabel;
+    }
+
+    /**
+     * Submits the MFA challenge (e.g., OTP code) to complete the authentication.
+     * @param challenge The challenge code (e.g., OTP code) entered by the user.
+     * @returns Promise that resolves to MfaSubmitChallengeResult.
+     * @warning This API is experimental. It may be changed in the future without notice. Do not use in production applications.
+     */
+    async submitChallenge(
+        challenge: string
+    ): Promise<MfaSubmitChallengeResult> {
+        try {
+            this.ensureCodeIsValid(challenge, this.getCodeLength());
+
+            this.stateParameters.logger.verbose(
+                "Submitting MFA challenge.",
+                this.stateParameters.correlationId
+            );
+
+            const submitParams: MfaSubmitChallengeParams = {
+                correlationId: this.stateParameters.correlationId,
+                continuationToken: this.stateParameters.continuationToken ?? "",
+                scopes: this.stateParameters.scopes ?? [],
+                challenge: challenge,
+            };
+
+            const result = await this.stateParameters.mfaClient.submitChallenge(
+                submitParams
+            );
+
+            this.stateParameters.logger.verbose(
+                "MFA challenge submitted successfully.",
+                this.stateParameters.correlationId
+            );
+
+            const accountInfo = new CustomAuthAccountData(
+                result.authenticationResult.account,
+                this.stateParameters.config,
+                this.stateParameters.cacheClient,
+                this.stateParameters.logger,
+                this.stateParameters.correlationId
+            );
+
+            return new MfaSubmitChallengeResult(
+                new MfaCompletedState(),
+                accountInfo
+            );
+        } catch (error) {
+            this.stateParameters.logger.errorPii(
+                `Failed to submit MFA challenge. Error: ${error}.`,
+                this.stateParameters.correlationId
+            );
+
+            return MfaSubmitChallengeResult.createWithError(error);
+        }
+    }
+}

package/src/custom_auth/core/auth_flow/mfa/state/MfaStateParameters.ts

@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { AuthFlowActionRequiredStateParameters } from "../../AuthFlowState.js";
+import { MfaClient } from "../../../interaction_client/mfa/MfaClient.js";
+import { AuthenticationMethod } from "../../../network_client/custom_auth_api/types/ApiResponseTypes.js";
+import { CustomAuthSilentCacheClient } from "../../../../get_account/interaction_client/CustomAuthSilentCacheClient.js";
+
+export interface MfaStateParameters
+    extends AuthFlowActionRequiredStateParameters {
+    mfaClient: MfaClient;
+    cacheClient: CustomAuthSilentCacheClient;
+    scopes?: string[];
+}
+
+export interface MfaVerificationRequiredStateParameters
+    extends MfaStateParameters {
+    challengeChannel: string;
+    challengeTargetLabel: string;
+    codeLength: number;
+    selectedAuthMethodId?: string;
+}
+
+export interface MfaAwaitingStateParameters extends MfaStateParameters {
+    authMethods: AuthenticationMethod[];
+}

package/src/custom_auth/core/interaction_client/CustomAuthInteractionClientBase.ts

@@ -103,7 +103,7 @@ export abstract class CustomAuthInteractionClientBase extends StandardInteractio
 
         const requestTimestamp = Math.round(new Date().getTime() / 1000.0);
 
-        // Save tokens and create authentication result 44s
+        // Save tokens and create authentication result
         const result =
             await this.tokenResponseHandler.handleServerTokenResponse(
                 tokenResponse,

package/src/custom_auth/core/interaction_client/jit/JitClient.ts

@@ -5,15 +5,12 @@
 
 import { CustomAuthInteractionClientBase } from "../CustomAuthInteractionClientBase.js";
 import {
-    JitGetAuthMethodsParams,
     JitChallengeAuthMethodParams,
     JitSubmitChallengeParams,
 } from "./parameter/JitParams.js";
 import {
-    JitGetAuthMethodsResult,
     JitVerificationRequiredResult,
     JitCompletedResult,
-    createJitGetAuthMethodsResult,
     createJitVerificationRequiredResult,
     createJitCompletedResult,
 } from "./result/JitActionResult.js";
@@ -24,7 +21,6 @@ import {
 } from "../../../CustomAuthConstants.js";
 import * as PublicApiId from "../../telemetry/PublicApiId.js";
 import {
-    RegisterIntrospectRequest,
     RegisterChallengeRequest,
     RegisterContinueRequest,
     SignInContinuationTokenRequest,
@@ -34,43 +30,6 @@ import {
  * JIT client for handling just-in-time authentication method registration flows.
  */
 export class JitClient extends CustomAuthInteractionClientBase {
-    /**
-     * Gets available authentication methods for JIT registration.
-     * @param parameters The parameters for getting auth methods.
-     * @returns Promise that resolves to JitGetAuthMethodsResult.
-     */
-    async getAuthMethods(
-        parameters: JitGetAuthMethodsParams
-    ): Promise<JitGetAuthMethodsResult> {
-        const apiId = PublicApiId.JIT_GET_AUTH_METHODS;
-        const telemetryManager = this.initializeServerTelemetryManager(apiId);
-
-        this.logger.verbose(
-            "Calling introspect endpoint for getting auth methods.",
-            parameters.correlationId
-        );
-
-        const request: RegisterIntrospectRequest = {
-            continuation_token: parameters.continuationToken,
-            correlationId: parameters.correlationId,
-            telemetryManager: telemetryManager,
-        };
-
-        const introspectResponse =
-            await this.customAuthApiClient.registerApi.introspect(request);
-
-        this.logger.verbose(
-            "Introspect endpoint called for getting auth methods.",
-            parameters.correlationId
-        );
-
-        return createJitGetAuthMethodsResult({
-            correlationId: introspectResponse.correlation_id,
-            continuationToken: introspectResponse.continuation_token,
-            authMethods: introspectResponse.methods,
-        });
-    }
-
     /**
      * Challenges an authentication method for JIT registration.
      * @param parameters The parameters for challenging the auth method.
@@ -195,7 +154,7 @@ export class JitClient extends CustomAuthInteractionClientBase {
         const authResult = await this.handleTokenResponse(
             tokenResponse,
             scopes,
-            continueResponse.correlation_id
+            tokenResponse.correlation_id || continueResponse.correlation_id
         );
 
         return createJitCompletedResult({

package/src/custom_auth/core/interaction_client/jit/parameter/JitParams.ts

@@ -10,8 +10,6 @@ export interface JitClientParametersBase {
     continuationToken: string;
 }
 
-export type JitGetAuthMethodsParams = JitClientParametersBase;
-
 export interface JitChallengeAuthMethodParams extends JitClientParametersBase {
     authMethod: AuthenticationMethod;
     verificationContact: string;

package/src/custom_auth/core/interaction_client/jit/result/JitActionResult.ts

@@ -4,25 +4,15 @@
  */
 
 import { AuthenticationResult } from "../../../../../response/AuthenticationResult.js";
-import { AuthenticationMethod } from "../../../network_client/custom_auth_api/types/ApiResponseTypes.js";
 
 interface JitActionResult {
     type: string;
     correlationId: string;
 }
 
-interface JitContinuationTokenResult extends JitActionResult {
-    continuationToken: string;
-}
-
-export interface JitGetAuthMethodsResult extends JitContinuationTokenResult {
-    type: typeof JIT_GET_AUTH_METHODS_RESULT_TYPE;
-    authMethods: AuthenticationMethod[];
-}
-
-export interface JitVerificationRequiredResult
-    extends JitContinuationTokenResult {
+export interface JitVerificationRequiredResult extends JitActionResult {
     type: typeof JIT_VERIFICATION_REQUIRED_RESULT_TYPE;
+    continuationToken: string;
     challengeChannel: string;
     challengeTargetLabel: string;
     codeLength: number;
@@ -34,20 +24,10 @@ export interface JitCompletedResult extends JitActionResult {
 }
 
 // Result type constants
-export const JIT_GET_AUTH_METHODS_RESULT_TYPE = "JitGetAuthMethodsResult";
 export const JIT_VERIFICATION_REQUIRED_RESULT_TYPE =
     "JitVerificationRequiredResult";
 export const JIT_COMPLETED_RESULT_TYPE = "JitCompletedResult";
 
-export function createJitGetAuthMethodsResult(
-    input: Omit<JitGetAuthMethodsResult, "type">
-): JitGetAuthMethodsResult {
-    return {
-        type: JIT_GET_AUTH_METHODS_RESULT_TYPE,
-        ...input,
-    };
-}
-
 export function createJitVerificationRequiredResult(
     input: Omit<JitVerificationRequiredResult, "type">
 ): JitVerificationRequiredResult {

package/src/custom_auth/core/interaction_client/mfa/MfaClient.ts

@@ -0,0 +1,148 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { CustomAuthInteractionClientBase } from "../CustomAuthInteractionClientBase.js";
+import {
+    MfaRequestChallengeParams,
+    MfaSubmitChallengeParams,
+} from "./parameter/MfaClientParameters.js";
+import {
+    MfaVerificationRequiredResult,
+    MfaCompletedResult,
+    createMfaVerificationRequiredResult,
+    createMfaCompletedResult,
+} from "./result/MfaActionResult.js";
+import {
+    DefaultCustomAuthApiCodeLength,
+    ChallengeType,
+    GrantType,
+} from "../../../CustomAuthConstants.js";
+import * as PublicApiId from "../../telemetry/PublicApiId.js";
+import {
+    SignInChallengeRequest,
+    SignInOobTokenRequest,
+} from "../../network_client/custom_auth_api/types/ApiRequestTypes.js";
+import { ensureArgumentIsNotEmptyString } from "../../utils/ArgumentValidator.js";
+import { CustomAuthApiError } from "../../error/CustomAuthApiError.js";
+import * as CustomAuthApiErrorCode from "../../network_client/custom_auth_api/types/ApiErrorCodes.js";
+
+/**
+ * MFA client for handling multi-factor authentication flows.
+ */
+export class MfaClient extends CustomAuthInteractionClientBase {
+    /**
+     * Requests an MFA challenge to be sent to the user.
+     * @param parameters The parameters for requesting the challenge.
+     * @returns Promise that resolves to either MfaVerificationRequiredResult.
+     */
+    async requestChallenge(
+        parameters: MfaRequestChallengeParams
+    ): Promise<MfaVerificationRequiredResult> {
+        const apiId = PublicApiId.MFA_REQUEST_CHALLENGE;
+        const telemetryManager = this.initializeServerTelemetryManager(apiId);
+
+        this.logger.verbose(
+            "Calling challenge endpoint for MFA.",
+            parameters.correlationId
+        );
+
+        const challengeReq: SignInChallengeRequest = {
+            challenge_type: this.getChallengeTypes(parameters.challengeType),
+            continuation_token: parameters.continuationToken,
+            id: parameters.authMethodId,
+            correlationId: parameters.correlationId,
+            telemetryManager: telemetryManager,
+        };
+
+        const challengeResponse =
+            await this.customAuthApiClient.signInApi.requestChallenge(
+                challengeReq
+            );
+
+        this.logger.verbose(
+            "Challenge endpoint called for MFA.",
+            parameters.correlationId
+        );
+
+        if (challengeResponse.challenge_type === ChallengeType.OOB) {
+            // Verification required - code will be sent
+            return createMfaVerificationRequiredResult({
+                correlationId: challengeResponse.correlation_id,
+                continuationToken: challengeResponse.continuation_token ?? "",
+                challengeChannel: challengeResponse.challenge_channel ?? "",
+                challengeTargetLabel:
+                    challengeResponse.challenge_target_label ?? "",
+                codeLength:
+                    challengeResponse.code_length ??
+                    DefaultCustomAuthApiCodeLength,
+                bindingMethod: challengeResponse.binding_method ?? "",
+            });
+        }
+
+        this.logger.error(
+            `Unsupported challenge type '${challengeResponse.challenge_type}' for MFA.`,
+            parameters.correlationId
+        );
+
+        throw new CustomAuthApiError(
+            CustomAuthApiErrorCode.UNSUPPORTED_CHALLENGE_TYPE,
+            `Unsupported challenge type '${challengeResponse.challenge_type}'.`,
+            challengeResponse.correlation_id
+        );
+    }
+
+    /**
+     * Submits the MFA challenge response (e.g., OTP code).
+     * @param parameters The parameters for submitting the challenge.
+     * @returns Promise that resolves to MfaCompletedResult.
+     */
+    async submitChallenge(
+        parameters: MfaSubmitChallengeParams
+    ): Promise<MfaCompletedResult> {
+        ensureArgumentIsNotEmptyString(
+            "parameters.challenge",
+            parameters.challenge,
+            parameters.correlationId
+        );
+
+        const apiId = PublicApiId.MFA_SUBMIT_CHALLENGE;
+        const telemetryManager = this.initializeServerTelemetryManager(apiId);
+        const scopes = this.getScopes(parameters.scopes);
+
+        const request: SignInOobTokenRequest = {
+            continuation_token: parameters.continuationToken,
+            oob: parameters.challenge,
+            grant_type: GrantType.MFA_OOB,
+            scope: scopes.join(" "),
+            correlationId: parameters.correlationId,
+            telemetryManager: telemetryManager,
+            ...(parameters.claims && {
+                claims: parameters.claims,
+            }),
+        };
+
+        this.logger.verbose(
+            "Calling token endpoint for MFA challenge submission.",
+            parameters.correlationId
+        );
+
+        const tokenResponse =
+            await this.customAuthApiClient.signInApi.requestTokensWithOob(
+                request
+            );
+
+        // Save tokens and create authentication result
+        const result = await this.handleTokenResponse(
+            tokenResponse,
+            scopes,
+            tokenResponse.correlation_id ?? parameters.correlationId
+        );
+
+        return createMfaCompletedResult({
+            correlationId: parameters.correlationId,
+            authenticationResult: result,
+        });
+    }
+}

package/src/custom_auth/core/interaction_client/mfa/parameter/MfaClientParameters.ts

@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+export interface MfaClientParametersBase {
+    correlationId: string;
+    continuationToken: string;
+}
+
+export interface MfaRequestChallengeParams extends MfaClientParametersBase {
+    challengeType: string[];
+    authMethodId: string;
+}
+
+export interface MfaSubmitChallengeParams extends MfaClientParametersBase {
+    challenge: string;
+    scopes: string[];
+    claims?: string;
+}

package/src/custom_auth/core/interaction_client/mfa/result/MfaActionResult.ts

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { AuthenticationResult } from "../../../../../response/AuthenticationResult.js";
+
+interface MfaActionResult {
+    type: string;
+    correlationId: string;
+}
+
+export interface MfaVerificationRequiredResult extends MfaActionResult {
+    type: typeof MFA_VERIFICATION_REQUIRED_RESULT_TYPE;
+    continuationToken: string;
+    challengeChannel: string;
+    challengeTargetLabel: string;
+    codeLength: number;
+    bindingMethod: string;
+}
+
+export interface MfaCompletedResult extends MfaActionResult {
+    type: typeof MFA_COMPLETED_RESULT_TYPE;
+    authenticationResult: AuthenticationResult;
+}
+
+// Result type constants
+export const MFA_VERIFICATION_REQUIRED_RESULT_TYPE =
+    "MfaVerificationRequiredResult";
+export const MFA_COMPLETED_RESULT_TYPE = "MfaCompletedResult";
+
+export function createMfaVerificationRequiredResult(
+    input: Omit<MfaVerificationRequiredResult, "type">
+): MfaVerificationRequiredResult {
+    return {
+        type: MFA_VERIFICATION_REQUIRED_RESULT_TYPE,
+        ...input,
+    };
+}
+
+export function createMfaCompletedResult(
+    input: Omit<MfaCompletedResult, "type">
+): MfaCompletedResult {
+    return {
+        type: MFA_COMPLETED_RESULT_TYPE,
+        ...input,
+    };
+}

package/src/custom_auth/core/network_client/custom_auth_api/CustomAuthApiEndpoint.ts

@@ -6,6 +6,7 @@
 export const SIGNIN_INITIATE = "/oauth2/v2.0/initiate";
 export const SIGNIN_CHALLENGE = "/oauth2/v2.0/challenge";
 export const SIGNIN_TOKEN = "/oauth2/v2.0/token";
+export const SIGNIN_INTROSPECT = "/oauth2/v2.0/introspect";
 
 export const SIGNUP_START = "/signup/v1.0/start";
 export const SIGNUP_CHALLENGE = "/signup/v1.0/challenge";

package/src/custom_auth/core/network_client/custom_auth_api/SignInApiClient.ts

@@ -14,12 +14,14 @@ import {
     SignInChallengeRequest,
     SignInContinuationTokenRequest,
     SignInInitiateRequest,
+    SignInIntrospectRequest,
     SignInOobTokenRequest,
     SignInPasswordTokenRequest,
 } from "./types/ApiRequestTypes.js";
 import {
     SignInChallengeResponse,
     SignInInitiateResponse,
+    SignInIntrospectResponse,
     SignInTokenResponse,
 } from "./types/ApiResponseTypes.js";
 
@@ -128,7 +130,7 @@ export class SignInApiClient extends BaseApiClient {
                 continuation_token: params.continuation_token,
                 scope: params.scope,
                 oob: params.oob,
-                grant_type: GrantType.OOB,
+                grant_type: params.grant_type,
                 ...(params.claims && { claims: params.claims }),
             },
             params.telemetryManager,
@@ -153,6 +155,30 @@ export class SignInApiClient extends BaseApiClient {
         );
     }
 
+    /**
+     * Requests available authentication methods for MFA
+     * @param continuationToken Token from previous response
+     */
+    async requestAuthMethods(
+        params: SignInIntrospectRequest
+    ): Promise<SignInIntrospectResponse> {
+        const result = await this.request<SignInIntrospectResponse>(
+            CustomAuthApiEndpoint.SIGNIN_INTROSPECT,
+            {
+                continuation_token: params.continuation_token,
+            },
+            params.telemetryManager,
+            params.correlationId
+        );
+
+        this.ensureContinuationTokenIsValid(
+            result.continuation_token,
+            params.correlationId
+        );
+
+        return result;
+    }
+
     private async requestTokens(
         requestData: Record<string, string | boolean>,
         telemetryManager: ServerTelemetryManager,

package/src/custom_auth/core/network_client/custom_auth_api/types/ApiRequestTypes.ts

@@ -3,6 +3,7 @@
  * Licensed under the MIT License.
  */
 
+import { GrantType } from "../../../../CustomAuthConstants.js";
 import { ApiRequestBase } from "./ApiTypesBase.js";
 
 /* Sign-in API request types */
@@ -29,12 +30,17 @@ export interface SignInPasswordTokenRequest extends SignInTokenRequestBase {
 
 export interface SignInOobTokenRequest extends SignInTokenRequestBase {
     oob: string;
+    grant_type: typeof GrantType.OOB | typeof GrantType.MFA_OOB;
 }
 
 export interface SignInContinuationTokenRequest extends SignInTokenRequestBase {
     username?: string;
 }
 
+export interface SignInIntrospectRequest extends ApiRequestBase {
+    continuation_token: string;
+}
+
 /* Sign-up API request types */
 export interface SignUpStartRequest extends ApiRequestBase {
     username: string;

package/src/custom_auth/core/network_client/custom_auth_api/types/ApiResponseTypes.ts

@@ -42,7 +42,12 @@ export interface AuthenticationMethod {
     id: string;
     challenge_type: string;
     challenge_channel: string;
-    login_hint: string;
+    login_hint?: string;
+}
+
+export interface SignInIntrospectResponse extends ApiResponseBase {
+    continuation_token: string;
+    methods: AuthenticationMethod[];
 }
 
 /* Sign-up API response types */