@azure/msal-browser 4.22.1 → 4.23.0

package/src/custom_auth/core/auth_flow/jit/state/AuthMethodRegistrationState.ts

@@ -0,0 +1,260 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import {
+    AuthMethodRegistrationStateParameters,
+    AuthMethodRegistrationRequiredStateParameters,
+    AuthMethodVerificationRequiredStateParameters,
+} from "./AuthMethodRegistrationStateParameters.js";
+import { AuthMethodDetails } from "../AuthMethodDetails.js";
+import {
+    JitChallengeAuthMethodParams,
+    JitSubmitChallengeParams,
+} from "../../../interaction_client/jit/parameter/JitParams.js";
+import { CustomAuthAccountData } from "../../../../get_account/auth_flow/CustomAuthAccountData.js";
+import {
+    JIT_VERIFICATION_REQUIRED_RESULT_TYPE,
+    JIT_COMPLETED_RESULT_TYPE,
+} from "../../../interaction_client/jit/result/JitActionResult.js";
+import { UnexpectedError } from "../../../error/UnexpectedError.js";
+import { AuthenticationMethod } from "../../../network_client/custom_auth_api/types/ApiResponseTypes.js";
+import { AuthFlowActionRequiredStateBase } from "../../AuthFlowState.js";
+import { GrantType } from "../../../../CustomAuthConstants.js";
+import { AuthMethodRegistrationChallengeMethodResult } from "../result/AuthMethodRegistrationChallengeMethodResult.js";
+import { AuthMethodRegistrationSubmitChallengeResult } from "../result/AuthMethodRegistrationSubmitChallengeResult.js";
+import { AuthMethodRegistrationCompletedState } from "./AuthMethodRegistrationCompletedState.js";
+
+/**
+ * Abstract base class for authentication method registration states.
+ */
+abstract class AuthMethodRegistrationState<
+    TParameters extends AuthMethodRegistrationStateParameters
+> extends AuthFlowActionRequiredStateBase<TParameters> {
+    /**
+     * Internal method to challenge an authentication method.
+     * @param authMethodDetails The authentication method details to challenge.
+     * @returns Promise that resolves to AuthMethodRegistrationChallengeMethodResult.
+     */
+    protected async challengeAuthMethodInternal(
+        authMethodDetails: AuthMethodDetails
+    ): Promise<AuthMethodRegistrationChallengeMethodResult> {
+        try {
+            this.stateParameters.logger.verbose(
+                `Challenging authentication method - '${authMethodDetails.authMethodType.id}' for auth method registration.`,
+                this.stateParameters.correlationId
+            );
+
+            const challengeParams: JitChallengeAuthMethodParams = {
+                correlationId: this.stateParameters.correlationId,
+                continuationToken: this.stateParameters.continuationToken ?? "",
+                authMethod: authMethodDetails.authMethodType,
+                verificationContact: authMethodDetails.verificationContact,
+                scopes: this.stateParameters.scopes ?? [],
+                username: this.stateParameters.username,
+                claims: this.stateParameters.claims,
+            };
+
+            const result =
+                await this.stateParameters.jitClient.challengeAuthMethod(
+                    challengeParams
+                );
+
+            this.stateParameters.logger.verbose(
+                "Authentication method challenged successfully for auth method registration.",
+                this.stateParameters.correlationId
+            );
+
+            if (result.type === JIT_VERIFICATION_REQUIRED_RESULT_TYPE) {
+                // Verification required
+                this.stateParameters.logger.verbose(
+                    "Auth method verification required.",
+                    this.stateParameters.correlationId
+                );
+
+                return new AuthMethodRegistrationChallengeMethodResult(
+                    new AuthMethodVerificationRequiredState({
+                        correlationId: result.correlationId,
+                        continuationToken: result.continuationToken,
+                        config: this.stateParameters.config,
+                        logger: this.stateParameters.logger,
+                        jitClient: this.stateParameters.jitClient,
+                        cacheClient: this.stateParameters.cacheClient,
+                        challengeChannel: result.challengeChannel,
+                        challengeTargetLabel: result.challengeTargetLabel,
+                        codeLength: result.codeLength,
+                        scopes: this.stateParameters.scopes ?? [],
+                        username: this.stateParameters.username,
+                        claims: this.stateParameters.claims,
+                    })
+                );
+            } else if (result.type === JIT_COMPLETED_RESULT_TYPE) {
+                // Registration completed (fast-pass scenario)
+                this.stateParameters.logger.verbose(
+                    "Auth method registration completed via fast-pass.",
+                    this.stateParameters.correlationId
+                );
+
+                const accountInfo = new CustomAuthAccountData(
+                    result.authenticationResult.account,
+                    this.stateParameters.config,
+                    this.stateParameters.cacheClient,
+                    this.stateParameters.logger,
+                    this.stateParameters.correlationId
+                );
+
+                return new AuthMethodRegistrationChallengeMethodResult(
+                    new AuthMethodRegistrationCompletedState(),
+                    accountInfo
+                );
+            } else {
+                // Handle unexpected result type with proper typing
+                this.stateParameters.logger.error(
+                    "Unexpected result type from auth challenge method",
+                    this.stateParameters.correlationId
+                );
+                throw new UnexpectedError(
+                    "Unexpected result type from auth challenge method"
+                );
+            }
+        } catch (error) {
+            this.stateParameters.logger.error(
+                "Failed to challenge authentication method for auth method registration.",
+                this.stateParameters.correlationId
+            );
+            return AuthMethodRegistrationChallengeMethodResult.createWithError(
+                error
+            );
+        }
+    }
+}
+
+/**
+ * State indicating that authentication method registration is required.
+ */
+export class AuthMethodRegistrationRequiredState extends AuthMethodRegistrationState<AuthMethodRegistrationRequiredStateParameters> {
+    /**
+     * Gets the available authentication methods for registration.
+     * @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;
+    }
+
+    /**
+     * Challenges an authentication method for registration.
+     * @param authMethodDetails The authentication method details to challenge.
+     * @returns Promise that resolves to AuthMethodRegistrationChallengeMethodResult.
+     * @warning This API is experimental. It may be changed in the future without notice. Do not use in production applications.
+     */
+    async challengeAuthMethod(
+        authMethodDetails: AuthMethodDetails
+    ): Promise<AuthMethodRegistrationChallengeMethodResult> {
+        return this.challengeAuthMethodInternal(authMethodDetails);
+    }
+}
+
+/**
+ * State indicating that verification is required for the challenged authentication method.
+ */
+export class AuthMethodVerificationRequiredState extends AuthMethodRegistrationState<AuthMethodVerificationRequiredStateParameters> {
+    /**
+     * Gets the length of the expected verification code.
+     * @returns The 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 verification challenge to complete the authentication method registration.
+     * @param code The verification code entered by the user.
+     * @returns Promise that resolves to AuthMethodRegistrationSubmitChallengeResult.
+     * @warning This API is experimental. It may be changed in the future without notice. Do not use in production applications.
+     */
+    async submitChallenge(
+        code: string
+    ): Promise<AuthMethodRegistrationSubmitChallengeResult> {
+        try {
+            this.ensureCodeIsValid(code, this.getCodeLength());
+
+            this.stateParameters.logger.verbose(
+                "Submitting auth method challenge.",
+                this.stateParameters.correlationId
+            );
+
+            const submitParams: JitSubmitChallengeParams = {
+                correlationId: this.stateParameters.correlationId,
+                continuationToken: this.stateParameters.continuationToken ?? "",
+                scopes: this.stateParameters.scopes ?? [],
+                grantType: GrantType.OOB,
+                challenge: code,
+                username: this.stateParameters.username,
+                claims: this.stateParameters.claims,
+            };
+
+            const result = await this.stateParameters.jitClient.submitChallenge(
+                submitParams
+            );
+
+            this.stateParameters.logger.verbose(
+                "Auth method 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 AuthMethodRegistrationSubmitChallengeResult(
+                new AuthMethodRegistrationCompletedState(),
+                accountInfo
+            );
+        } catch (error) {
+            this.stateParameters.logger.error(
+                "Failed to submit auth method challenge.",
+                this.stateParameters.correlationId
+            );
+            return AuthMethodRegistrationSubmitChallengeResult.createWithError(
+                error
+            );
+        }
+    }
+
+    /**
+     * Challenges a different authentication method for registration.
+     * @param authMethodDetails The authentication method details to challenge.
+     * @returns Promise that resolves to AuthMethodRegistrationChallengeMethodResult.
+     * @warning This API is experimental. It may be changed in the future without notice. Do not use in production applications.
+     */
+    async challengeAuthMethod(
+        authMethodDetails: AuthMethodDetails
+    ): Promise<AuthMethodRegistrationChallengeMethodResult> {
+        return this.challengeAuthMethodInternal(authMethodDetails);
+    }
+}

package/src/custom_auth/core/auth_flow/jit/state/AuthMethodRegistrationStateParameters.ts

@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { AuthFlowActionRequiredStateParameters } from "../../AuthFlowState.js";
+import { JitClient } from "../../../interaction_client/jit/JitClient.js";
+import { AuthenticationMethod } from "../../../network_client/custom_auth_api/types/ApiResponseTypes.js";
+import { CustomAuthSilentCacheClient } from "../../../../get_account/interaction_client/CustomAuthSilentCacheClient.js";
+
+export interface AuthMethodRegistrationStateParameters
+    extends AuthFlowActionRequiredStateParameters {
+    jitClient: JitClient;
+    cacheClient: CustomAuthSilentCacheClient;
+    scopes?: string[];
+    username?: string;
+    claims?: string;
+}
+
+export interface AuthMethodRegistrationRequiredStateParameters
+    extends AuthMethodRegistrationStateParameters {
+    authMethods: AuthenticationMethod[];
+}
+
+export interface AuthMethodVerificationRequiredStateParameters
+    extends AuthMethodRegistrationStateParameters {
+    challengeChannel: string;
+    challengeTargetLabel: string;
+    codeLength: number;
+}

package/src/custom_auth/core/error/MsalCustomAuthError.ts

@@ -6,17 +6,14 @@
 import { CustomAuthError } from "./CustomAuthError.js";
 
 export class MsalCustomAuthError extends CustomAuthError {
-    subError: string | undefined;
-
     constructor(
         error: string,
         errorDescription?: string,
         subError?: string,
+        errorCodes?: Array<number>,
         correlationId?: string
     ) {
-        super(error, errorDescription, correlationId);
+        super(error, errorDescription, correlationId, errorCodes, subError);
         Object.setPrototypeOf(this, MsalCustomAuthError.prototype);
-
-        this.subError = subError || "";
     }
 }

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

@@ -15,6 +15,7 @@ import {
     ICrypto,
     IPerformanceClient,
     Logger,
+    ResponseHandler,
 } from "@azure/msal-common/browser";
 import { EventHandler } from "../../../event/EventHandler.js";
 import { INavigationClient } from "../../../navigation/INavigationClient.js";
@@ -24,8 +25,11 @@ import { SsoSilentRequest } from "../../../request/SsoSilentRequest.js";
 import { EndSessionRequest } from "../../../request/EndSessionRequest.js";
 import { ClearCacheRequest } from "../../../request/ClearCacheRequest.js";
 import { AuthenticationResult } from "../../../response/AuthenticationResult.js";
+import { SignInTokenResponse } from "../network_client/custom_auth_api/types/ApiResponseTypes.js";
 
 export abstract class CustomAuthInteractionClientBase extends StandardInteractionClient {
+    private readonly tokenResponseHandler: ResponseHandler;
+
     constructor(
         config: BrowserConfiguration,
         storageImpl: BrowserCacheManager,
@@ -46,6 +50,15 @@ export abstract class CustomAuthInteractionClientBase extends StandardInteractio
             navigationClient,
             performanceClient
         );
+
+        this.tokenResponseHandler = new ResponseHandler(
+            this.config.auth.clientId,
+            this.browserStorage,
+            this.browserCrypto,
+            this.logger,
+            null,
+            null
+        );
     }
 
     protected getChallengeTypes(
@@ -74,6 +87,39 @@ export abstract class CustomAuthInteractionClientBase extends StandardInteractio
         ];
     }
 
+    /**
+     * Common method to handle token response processing.
+     * @param tokenResponse The token response from the API
+     * @param requestScopes Scopes for the token request
+     * @param correlationId Correlation ID for logging
+     * @returns Authentication result from the token response
+     */
+    protected async handleTokenResponse(
+        tokenResponse: SignInTokenResponse,
+        requestScopes: string[],
+        correlationId: string
+    ): Promise<AuthenticationResult> {
+        this.logger.verbose("Processing token response.", correlationId);
+
+        const requestTimestamp = Math.round(new Date().getTime() / 1000.0);
+
+        // Save tokens and create authentication result 44s
+        const result =
+            await this.tokenResponseHandler.handleServerTokenResponse(
+                tokenResponse,
+                this.customAuthAuthority,
+                requestTimestamp,
+                {
+                    authority: this.customAuthAuthority.canonicalAuthority,
+                    correlationId:
+                        tokenResponse.correlation_id ?? correlationId,
+                    scopes: requestScopes,
+                }
+            );
+
+        return result as AuthenticationResult;
+    }
+
     // It is not necessary to implement this method from base class.
     acquireToken(
         // eslint-disable-next-line @typescript-eslint/no-unused-vars

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

@@ -0,0 +1,206 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { CustomAuthInteractionClientBase } from "../CustomAuthInteractionClientBase.js";
+import {
+    JitGetAuthMethodsParams,
+    JitChallengeAuthMethodParams,
+    JitSubmitChallengeParams,
+} from "./parameter/JitParams.js";
+import {
+    JitGetAuthMethodsResult,
+    JitVerificationRequiredResult,
+    JitCompletedResult,
+    createJitGetAuthMethodsResult,
+    createJitVerificationRequiredResult,
+    createJitCompletedResult,
+} from "./result/JitActionResult.js";
+import {
+    DefaultCustomAuthApiCodeLength,
+    ChallengeType,
+    GrantType,
+} from "../../../CustomAuthConstants.js";
+import * as PublicApiId from "../../telemetry/PublicApiId.js";
+import {
+    RegisterIntrospectRequest,
+    RegisterChallengeRequest,
+    RegisterContinueRequest,
+    SignInContinuationTokenRequest,
+} from "../../network_client/custom_auth_api/types/ApiRequestTypes.js";
+
+/**
+ * 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.
+     * @returns Promise that resolves to either JitVerificationRequiredResult or JitCompletedResult.
+     */
+    async challengeAuthMethod(
+        parameters: JitChallengeAuthMethodParams
+    ): Promise<JitVerificationRequiredResult | JitCompletedResult> {
+        const apiId = PublicApiId.JIT_CHALLENGE_AUTH_METHOD;
+        const telemetryManager = this.initializeServerTelemetryManager(apiId);
+
+        this.logger.verbose(
+            "Calling challenge endpoint for getting auth method.",
+            parameters.correlationId
+        );
+
+        const challengeReq: RegisterChallengeRequest = {
+            continuation_token: parameters.continuationToken,
+            challenge_type: parameters.authMethod.challenge_type,
+            challenge_target: parameters.verificationContact,
+            challenge_channel: parameters.authMethod.challenge_channel,
+            correlationId: parameters.correlationId,
+            telemetryManager: telemetryManager,
+        };
+
+        const challengeResponse =
+            await this.customAuthApiClient.registerApi.challenge(challengeReq);
+
+        this.logger.verbose(
+            "Challenge endpoint called for auth method registration.",
+            parameters.correlationId
+        );
+
+        /*
+         * Handle fast-pass scenario (preverified)
+         * This occurs when the user selects the same email used during sign-up
+         * Since the email was already verified during sign-up, no additional verification is needed
+         */
+        if (challengeResponse.challenge_type === ChallengeType.PREVERIFIED) {
+            this.logger.verbose(
+                "Fast-pass scenario detected - completing registration without additional verification.",
+                challengeResponse.correlation_id
+            );
+
+            // Use submitChallenge for fast-pass scenario with continuation_token grant type
+            const fastPassParams: JitSubmitChallengeParams = {
+                correlationId: challengeResponse.correlation_id,
+                continuationToken: challengeResponse.continuation_token,
+                grantType: GrantType.CONTINUATION_TOKEN,
+                scopes: parameters.scopes,
+                username: parameters.username,
+                claims: parameters.claims,
+            };
+
+            const completedResult = await this.submitChallenge(fastPassParams);
+            return completedResult;
+        }
+
+        // Verification required
+        return createJitVerificationRequiredResult({
+            correlationId: challengeResponse.correlation_id,
+            continuationToken: challengeResponse.continuation_token,
+            challengeChannel: challengeResponse.challenge_channel,
+            challengeTargetLabel: challengeResponse.challenge_target,
+            codeLength:
+                challengeResponse.code_length || DefaultCustomAuthApiCodeLength,
+        });
+    }
+
+    /**
+     * Submits challenge response and completes JIT registration.
+     * @param parameters The parameters for submitting the challenge.
+     * @returns Promise that resolves to JitCompletedResult.
+     */
+    async submitChallenge(
+        parameters: JitSubmitChallengeParams
+    ): Promise<JitCompletedResult> {
+        const apiId = PublicApiId.JIT_SUBMIT_CHALLENGE;
+        const telemetryManager = this.initializeServerTelemetryManager(apiId);
+
+        this.logger.verbose(
+            "Calling continue endpoint for auth method challenge submission.",
+            parameters.correlationId
+        );
+
+        // Submit challenge to complete registration
+        const continueReq: RegisterContinueRequest = {
+            continuation_token: parameters.continuationToken,
+            grant_type: parameters.grantType,
+            ...(parameters.challenge && {
+                oob: parameters.challenge,
+            }),
+            correlationId: parameters.correlationId,
+            telemetryManager: telemetryManager,
+        };
+
+        const continueResponse =
+            await this.customAuthApiClient.registerApi.continue(continueReq);
+
+        this.logger.verbose(
+            "Continue endpoint called for auth method challenge submission.",
+            parameters.correlationId
+        );
+
+        // Use continuation token to get authentication tokens
+        const scopes = this.getScopes(parameters.scopes);
+        const tokenRequest: SignInContinuationTokenRequest = {
+            continuation_token: continueResponse.continuation_token,
+            scope: scopes.join(" "),
+            correlationId: continueResponse.correlation_id,
+            telemetryManager: telemetryManager,
+            ...(parameters.claims && {
+                claims: parameters.claims,
+            }),
+        };
+
+        const tokenResponse =
+            await this.customAuthApiClient.signInApi.requestTokenWithContinuationToken(
+                tokenRequest
+            );
+
+        const authResult = await this.handleTokenResponse(
+            tokenResponse,
+            scopes,
+            continueResponse.correlation_id
+        );
+
+        return createJitCompletedResult({
+            correlationId: continueResponse.correlation_id,
+            authenticationResult: authResult,
+        });
+    }
+}

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

@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { AuthenticationMethod } from "../../../network_client/custom_auth_api/types/ApiResponseTypes.js";
+
+export interface JitClientParametersBase {
+    correlationId: string;
+    continuationToken: string;
+}
+
+export type JitGetAuthMethodsParams = JitClientParametersBase;
+
+export interface JitChallengeAuthMethodParams extends JitClientParametersBase {
+    authMethod: AuthenticationMethod;
+    verificationContact: string;
+    scopes: string[];
+    username?: string;
+    claims?: string;
+}
+
+export interface JitSubmitChallengeParams extends JitClientParametersBase {
+    grantType: string;
+    challenge?: string;
+    scopes: string[];
+    username?: string;
+    claims?: string;
+}

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

@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+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 {
+    type: typeof JIT_VERIFICATION_REQUIRED_RESULT_TYPE;
+    challengeChannel: string;
+    challengeTargetLabel: string;
+    codeLength: number;
+}
+
+export interface JitCompletedResult extends JitActionResult {
+    type: typeof JIT_COMPLETED_RESULT_TYPE;
+    authenticationResult: AuthenticationResult;
+}
+
+// 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 {
+    return {
+        type: JIT_VERIFICATION_REQUIRED_RESULT_TYPE,
+        ...input,
+    };
+}
+
+export function createJitCompletedResult(
+    input: Omit<JitCompletedResult, "type">
+): JitCompletedResult {
+    return {
+        type: JIT_COMPLETED_RESULT_TYPE,
+        ...input,
+    };
+}