@azure/msal-browser 3.0.0-alpha.1 → 3.0.0-alpha.2

package/dist/interaction_client/SilentIframeClient.js

@@ -1,4 +1,4 @@
-/*! @azure/msal-browser v3.0.0-alpha.1 2023-05-08 */
+/*! @azure/msal-browser v3.0.0-alpha.2 2023-05-17 */
 'use strict';
 import { PerformanceEvents, StringUtils, PromptValue, Constants, AuthError, UrlString, ProtocolUtils } from '@azure/msal-common';
 import { StandardInteractionClient } from './StandardInteractionClient.js';
@@ -8,132 +8,132 @@ import { SilentHandler } from '../interaction_handler/SilentHandler.js';
 import { NativeMessageHandler } from '../broker/nativeBroker/NativeMessageHandler.js';
 import { NativeInteractionClient } from './NativeInteractionClient.js';
 
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-class SilentIframeClient extends StandardInteractionClient {
-    constructor(config, storageImpl, browserCrypto, logger, eventHandler, navigationClient, apiId, performanceClient, nativeStorageImpl, nativeMessageHandler, correlationId) {
-        super(config, storageImpl, browserCrypto, logger, eventHandler, navigationClient, performanceClient, nativeMessageHandler, correlationId);
-        this.apiId = apiId;
-        this.nativeStorage = nativeStorageImpl;
-    }
-    /**
-     * Acquires a token silently by opening a hidden iframe to the /authorize endpoint with prompt=none or prompt=no_session
-     * @param request
-     */
-    async acquireToken(request) {
-        this.performanceClient.addQueueMeasurement(PerformanceEvents.SilentIframeClientAcquireToken, request.correlationId);
-        this.logger.verbose("acquireTokenByIframe called");
-        const acquireTokenMeasurement = this.performanceClient.startMeasurement(PerformanceEvents.SilentIframeClientAcquireToken, request.correlationId);
-        // Check that we have some SSO data
-        if (StringUtils.isEmpty(request.loginHint) &&
-            StringUtils.isEmpty(request.sid) &&
-            (!request.account || StringUtils.isEmpty(request.account.username))) {
-            this.logger.warning("No user hint provided. The authorization server may need more information to complete this request.");
-        }
-        // Check that prompt is set to none or no_session, throw error if it is set to anything else.
-        if (request.prompt &&
-            request.prompt !== PromptValue.NONE &&
-            request.prompt !== PromptValue.NO_SESSION) {
-            acquireTokenMeasurement.endMeasurement({
-                success: false,
-            });
-            throw BrowserAuthError.createSilentPromptValueError(request.prompt);
-        }
-        // Create silent request
-        this.performanceClient.setPreQueueTime(PerformanceEvents.StandardInteractionClientInitializeAuthorizationRequest, request.correlationId);
-        const silentRequest = await this.initializeAuthorizationRequest({
-            ...request,
-            prompt: request.prompt || PromptValue.NONE,
-        }, InteractionType.Silent);
-        this.browserStorage.updateCacheEntries(silentRequest.state, silentRequest.nonce, silentRequest.authority, silentRequest.loginHint || Constants.EMPTY_STRING, silentRequest.account || null);
-        const serverTelemetryManager = this.initializeServerTelemetryManager(this.apiId);
-        try {
-            // Initialize the client
-            this.performanceClient.setPreQueueTime(PerformanceEvents.StandardInteractionClientCreateAuthCodeClient, request.correlationId);
-            const authClient = await this.createAuthCodeClient(serverTelemetryManager, silentRequest.authority, silentRequest.azureCloudOptions);
-            this.logger.verbose("Auth code client created");
-            this.performanceClient.setPreQueueTime(PerformanceEvents.SilentIframeClientTokenHelper, request.correlationId);
-            return await this.silentTokenHelper(authClient, silentRequest).then((result) => {
-                acquireTokenMeasurement.endMeasurement({
-                    success: true,
-                    fromCache: false,
-                    requestId: result.requestId,
-                });
-                return result;
-            });
-        }
-        catch (e) {
-            if (e instanceof AuthError) {
-                e.setCorrelationId(this.correlationId);
-                serverTelemetryManager.cacheFailedRequest(e);
-            }
-            this.browserStorage.cleanRequestByState(silentRequest.state);
-            acquireTokenMeasurement.endMeasurement({
-                errorCode: (e instanceof AuthError && e.errorCode) || undefined,
-                subErrorCode: (e instanceof AuthError && e.subError) || undefined,
-                success: false,
-            });
-            throw e;
-        }
-    }
-    /**
-     * Currently Unsupported
-     */
-    logout() {
-        // Synchronous so we must reject
-        return Promise.reject(BrowserAuthError.createSilentLogoutUnsupportedError());
-    }
-    /**
-     * Helper which acquires an authorization code silently using a hidden iframe from given url
-     * using the scopes requested as part of the id, and exchanges the code for a set of OAuth tokens.
-     * @param navigateUrl
-     * @param userRequestScopes
-     */
-    async silentTokenHelper(authClient, silentRequest) {
-        this.performanceClient.addQueueMeasurement(PerformanceEvents.SilentIframeClientTokenHelper, silentRequest.correlationId);
-        // Create auth code request and generate PKCE params
-        this.performanceClient.setPreQueueTime(PerformanceEvents.StandardInteractionClientInitializeAuthorizationCodeRequest, silentRequest.correlationId);
-        const authCodeRequest = await this.initializeAuthorizationCodeRequest(silentRequest);
-        // Create authorize request url
-        this.performanceClient.setPreQueueTime(PerformanceEvents.GetAuthCodeUrl, silentRequest.correlationId);
-        const navigateUrl = await authClient.getAuthCodeUrl({
-            ...silentRequest,
-            nativeBroker: NativeMessageHandler.isNativeAvailable(this.config, this.logger, this.nativeMessageHandler, silentRequest.authenticationScheme),
-        });
-        // Create silent handler
-        const silentHandler = new SilentHandler(authClient, this.browserStorage, authCodeRequest, this.logger, this.config.system, this.performanceClient);
-        // Get the frame handle for the silent request
-        this.performanceClient.setPreQueueTime(PerformanceEvents.SilentHandlerInitiateAuthRequest, silentRequest.correlationId);
-        const msalFrame = await silentHandler.initiateAuthRequest(navigateUrl);
-        // Monitor the window for the hash. Return the string value and close the popup when the hash is received. Default timeout is 60 seconds.
-        this.performanceClient.setPreQueueTime(PerformanceEvents.SilentHandlerMonitorIframeForHash, silentRequest.correlationId);
-        const hash = await silentHandler.monitorIframeForHash(msalFrame, this.config.system.iframeHashTimeout);
-        // Deserialize hash fragment response parameters.
-        const serverParams = UrlString.getDeserializedHash(hash);
-        const state = this.validateAndExtractStateFromHash(serverParams, InteractionType.Silent, authCodeRequest.correlationId);
-        if (serverParams.accountId) {
-            this.logger.verbose("Account id found in hash, calling WAM for token");
-            if (!this.nativeMessageHandler) {
-                throw BrowserAuthError.createNativeConnectionNotEstablishedError();
-            }
-            const nativeInteractionClient = new NativeInteractionClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, this.apiId, this.performanceClient, this.nativeMessageHandler, serverParams.accountId, this.browserStorage, this.correlationId);
-            const { userRequestState } = ProtocolUtils.parseRequestState(this.browserCrypto, state);
-            return nativeInteractionClient
-                .acquireToken({
-                ...silentRequest,
-                state: userRequestState,
-                prompt: silentRequest.prompt || PromptValue.NONE,
-            })
-                .finally(() => {
-                this.browserStorage.cleanRequestByState(state);
-            });
-        }
-        // Handle response from hash string
-        this.performanceClient.setPreQueueTime(PerformanceEvents.HandleCodeResponseFromHash, silentRequest.correlationId);
-        return silentHandler.handleCodeResponseFromHash(hash, state, authClient.authority, this.networkClient);
-    }
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+class SilentIframeClient extends StandardInteractionClient {
+    constructor(config, storageImpl, browserCrypto, logger, eventHandler, navigationClient, apiId, performanceClient, nativeStorageImpl, nativeMessageHandler, correlationId) {
+        super(config, storageImpl, browserCrypto, logger, eventHandler, navigationClient, performanceClient, nativeMessageHandler, correlationId);
+        this.apiId = apiId;
+        this.nativeStorage = nativeStorageImpl;
+    }
+    /**
+     * Acquires a token silently by opening a hidden iframe to the /authorize endpoint with prompt=none or prompt=no_session
+     * @param request
+     */
+    async acquireToken(request) {
+        this.performanceClient.addQueueMeasurement(PerformanceEvents.SilentIframeClientAcquireToken, request.correlationId);
+        this.logger.verbose("acquireTokenByIframe called");
+        const acquireTokenMeasurement = this.performanceClient.startMeasurement(PerformanceEvents.SilentIframeClientAcquireToken, request.correlationId);
+        // Check that we have some SSO data
+        if (StringUtils.isEmpty(request.loginHint) &&
+            StringUtils.isEmpty(request.sid) &&
+            (!request.account || StringUtils.isEmpty(request.account.username))) {
+            this.logger.warning("No user hint provided. The authorization server may need more information to complete this request.");
+        }
+        // Check that prompt is set to none or no_session, throw error if it is set to anything else.
+        if (request.prompt &&
+            request.prompt !== PromptValue.NONE &&
+            request.prompt !== PromptValue.NO_SESSION) {
+            acquireTokenMeasurement.endMeasurement({
+                success: false,
+            });
+            throw BrowserAuthError.createSilentPromptValueError(request.prompt);
+        }
+        // Create silent request
+        this.performanceClient.setPreQueueTime(PerformanceEvents.StandardInteractionClientInitializeAuthorizationRequest, request.correlationId);
+        const silentRequest = await this.initializeAuthorizationRequest({
+            ...request,
+            prompt: request.prompt || PromptValue.NONE,
+        }, InteractionType.Silent);
+        this.browserStorage.updateCacheEntries(silentRequest.state, silentRequest.nonce, silentRequest.authority, silentRequest.loginHint || Constants.EMPTY_STRING, silentRequest.account || null);
+        const serverTelemetryManager = this.initializeServerTelemetryManager(this.apiId);
+        try {
+            // Initialize the client
+            this.performanceClient.setPreQueueTime(PerformanceEvents.StandardInteractionClientCreateAuthCodeClient, request.correlationId);
+            const authClient = await this.createAuthCodeClient(serverTelemetryManager, silentRequest.authority, silentRequest.azureCloudOptions);
+            this.logger.verbose("Auth code client created");
+            this.performanceClient.setPreQueueTime(PerformanceEvents.SilentIframeClientTokenHelper, request.correlationId);
+            return await this.silentTokenHelper(authClient, silentRequest).then((result) => {
+                acquireTokenMeasurement.endMeasurement({
+                    success: true,
+                    fromCache: false,
+                    requestId: result.requestId,
+                });
+                return result;
+            });
+        }
+        catch (e) {
+            if (e instanceof AuthError) {
+                e.setCorrelationId(this.correlationId);
+                serverTelemetryManager.cacheFailedRequest(e);
+            }
+            this.browserStorage.cleanRequestByState(silentRequest.state);
+            acquireTokenMeasurement.endMeasurement({
+                errorCode: (e instanceof AuthError && e.errorCode) || undefined,
+                subErrorCode: (e instanceof AuthError && e.subError) || undefined,
+                success: false,
+            });
+            throw e;
+        }
+    }
+    /**
+     * Currently Unsupported
+     */
+    logout() {
+        // Synchronous so we must reject
+        return Promise.reject(BrowserAuthError.createSilentLogoutUnsupportedError());
+    }
+    /**
+     * Helper which acquires an authorization code silently using a hidden iframe from given url
+     * using the scopes requested as part of the id, and exchanges the code for a set of OAuth tokens.
+     * @param navigateUrl
+     * @param userRequestScopes
+     */
+    async silentTokenHelper(authClient, silentRequest) {
+        this.performanceClient.addQueueMeasurement(PerformanceEvents.SilentIframeClientTokenHelper, silentRequest.correlationId);
+        // Create auth code request and generate PKCE params
+        this.performanceClient.setPreQueueTime(PerformanceEvents.StandardInteractionClientInitializeAuthorizationCodeRequest, silentRequest.correlationId);
+        const authCodeRequest = await this.initializeAuthorizationCodeRequest(silentRequest);
+        // Create authorize request url
+        this.performanceClient.setPreQueueTime(PerformanceEvents.GetAuthCodeUrl, silentRequest.correlationId);
+        const navigateUrl = await authClient.getAuthCodeUrl({
+            ...silentRequest,
+            nativeBroker: NativeMessageHandler.isNativeAvailable(this.config, this.logger, this.nativeMessageHandler, silentRequest.authenticationScheme),
+        });
+        // Create silent handler
+        const silentHandler = new SilentHandler(authClient, this.browserStorage, authCodeRequest, this.logger, this.config.system, this.performanceClient);
+        // Get the frame handle for the silent request
+        this.performanceClient.setPreQueueTime(PerformanceEvents.SilentHandlerInitiateAuthRequest, silentRequest.correlationId);
+        const msalFrame = await silentHandler.initiateAuthRequest(navigateUrl);
+        // Monitor the window for the hash. Return the string value and close the popup when the hash is received. Default timeout is 60 seconds.
+        this.performanceClient.setPreQueueTime(PerformanceEvents.SilentHandlerMonitorIframeForHash, silentRequest.correlationId);
+        const hash = await silentHandler.monitorIframeForHash(msalFrame, this.config.system.iframeHashTimeout);
+        // Deserialize hash fragment response parameters.
+        const serverParams = UrlString.getDeserializedHash(hash);
+        const state = this.validateAndExtractStateFromHash(serverParams, InteractionType.Silent, authCodeRequest.correlationId);
+        if (serverParams.accountId) {
+            this.logger.verbose("Account id found in hash, calling WAM for token");
+            if (!this.nativeMessageHandler) {
+                throw BrowserAuthError.createNativeConnectionNotEstablishedError();
+            }
+            const nativeInteractionClient = new NativeInteractionClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, this.apiId, this.performanceClient, this.nativeMessageHandler, serverParams.accountId, this.browserStorage, this.correlationId);
+            const { userRequestState } = ProtocolUtils.parseRequestState(this.browserCrypto, state);
+            return nativeInteractionClient
+                .acquireToken({
+                ...silentRequest,
+                state: userRequestState,
+                prompt: silentRequest.prompt || PromptValue.NONE,
+            })
+                .finally(() => {
+                this.browserStorage.cleanRequestByState(state);
+            });
+        }
+        // Handle response from hash string
+        this.performanceClient.setPreQueueTime(PerformanceEvents.HandleCodeResponseFromHash, silentRequest.correlationId);
+        return silentHandler.handleCodeResponseFromHash(hash, state, authClient.authority, this.networkClient);
+    }
 }
 
 export { SilentIframeClient };

package/dist/interaction_client/SilentRefreshClient.d.ts

@@ -1,20 +1,20 @@
-import { StandardInteractionClient } from "./StandardInteractionClient";
-import { CommonSilentFlowRequest, AuthenticationResult, ServerTelemetryManager, RefreshTokenClient, AzureCloudOptions } from "@azure/msal-common";
-export declare class SilentRefreshClient extends StandardInteractionClient {
-    /**
-     * Exchanges the refresh token for new tokens
-     * @param request
-     */
-    acquireToken(request: CommonSilentFlowRequest): Promise<AuthenticationResult>;
-    /**
-     * Currently Unsupported
-     */
-    logout(): Promise<void>;
-    /**
-     * Creates a Refresh Client with the given authority, or the default authority.
-     * @param serverTelemetryManager
-     * @param authorityUrl
-     */
-    protected createRefreshTokenClient(serverTelemetryManager: ServerTelemetryManager, authorityUrl?: string, azureCloudOptions?: AzureCloudOptions): Promise<RefreshTokenClient>;
-}
+import { StandardInteractionClient } from "./StandardInteractionClient";
+import { CommonSilentFlowRequest, AuthenticationResult, ServerTelemetryManager, RefreshTokenClient, AzureCloudOptions } from "@azure/msal-common";
+export declare class SilentRefreshClient extends StandardInteractionClient {
+    /**
+     * Exchanges the refresh token for new tokens
+     * @param request
+     */
+    acquireToken(request: CommonSilentFlowRequest): Promise<AuthenticationResult>;
+    /**
+     * Currently Unsupported
+     */
+    logout(): Promise<void>;
+    /**
+     * Creates a Refresh Client with the given authority, or the default authority.
+     * @param serverTelemetryManager
+     * @param authorityUrl
+     */
+    protected createRefreshTokenClient(serverTelemetryManager: ServerTelemetryManager, authorityUrl?: string, azureCloudOptions?: AzureCloudOptions): Promise<RefreshTokenClient>;
+}
 //# sourceMappingURL=SilentRefreshClient.d.ts.map

package/dist/interaction_client/SilentRefreshClient.js

@@ -1,71 +1,71 @@
-/*! @azure/msal-browser v3.0.0-alpha.1 2023-05-08 */
+/*! @azure/msal-browser v3.0.0-alpha.2 2023-05-17 */
 'use strict';
 import { StandardInteractionClient } from './StandardInteractionClient.js';
 import { PerformanceEvents, RefreshTokenClient } from '@azure/msal-common';
 import { ApiId } from '../utils/BrowserConstants.js';
 import { BrowserAuthError } from '../error/BrowserAuthError.js';
 
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-class SilentRefreshClient extends StandardInteractionClient {
-    /**
-     * Exchanges the refresh token for new tokens
-     * @param request
-     */
-    async acquireToken(request) {
-        this.performanceClient.addQueueMeasurement(PerformanceEvents.SilentRefreshClientAcquireToken, request.correlationId);
-        this.performanceClient.setPreQueueTime(PerformanceEvents.InitializeBaseRequest, request.correlationId);
-        const silentRequest = {
-            ...request,
-            ...(await this.initializeBaseRequest(request)),
-        };
-        const acquireTokenMeasurement = this.performanceClient.startMeasurement(PerformanceEvents.SilentRefreshClientAcquireToken, silentRequest.correlationId);
-        const serverTelemetryManager = this.initializeServerTelemetryManager(ApiId.acquireTokenSilent_silentFlow);
-        const refreshTokenClient = await this.createRefreshTokenClient(serverTelemetryManager, silentRequest.authority, silentRequest.azureCloudOptions);
-        this.logger.verbose("Refresh token client created");
-        // Send request to renew token. Auth module will throw errors if token cannot be renewed.
-        this.performanceClient.setPreQueueTime(PerformanceEvents.RefreshTokenClientAcquireTokenByRefreshToken, request.correlationId);
-        return refreshTokenClient
-            .acquireTokenByRefreshToken(silentRequest)
-            .then((result) => {
-            acquireTokenMeasurement.endMeasurement({
-                success: true,
-                fromCache: result.fromCache,
-                requestId: result.requestId,
-            });
-            return result;
-        })
-            .catch((e) => {
-            e.setCorrelationId(this.correlationId);
-            serverTelemetryManager.cacheFailedRequest(e);
-            acquireTokenMeasurement.endMeasurement({
-                errorCode: e.errorCode,
-                subErrorCode: e.subError,
-                success: false,
-            });
-            throw e;
-        });
-    }
-    /**
-     * Currently Unsupported
-     */
-    logout() {
-        // Synchronous so we must reject
-        return Promise.reject(BrowserAuthError.createSilentLogoutUnsupportedError());
-    }
-    /**
-     * Creates a Refresh Client with the given authority, or the default authority.
-     * @param serverTelemetryManager
-     * @param authorityUrl
-     */
-    async createRefreshTokenClient(serverTelemetryManager, authorityUrl, azureCloudOptions) {
-        // Create auth module.
-        this.performanceClient.setPreQueueTime(PerformanceEvents.StandardInteractionClientGetClientConfiguration, this.correlationId);
-        const clientConfig = await this.getClientConfiguration(serverTelemetryManager, authorityUrl, azureCloudOptions);
-        return new RefreshTokenClient(clientConfig, this.performanceClient);
-    }
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+class SilentRefreshClient extends StandardInteractionClient {
+    /**
+     * Exchanges the refresh token for new tokens
+     * @param request
+     */
+    async acquireToken(request) {
+        this.performanceClient.addQueueMeasurement(PerformanceEvents.SilentRefreshClientAcquireToken, request.correlationId);
+        this.performanceClient.setPreQueueTime(PerformanceEvents.InitializeBaseRequest, request.correlationId);
+        const silentRequest = {
+            ...request,
+            ...(await this.initializeBaseRequest(request)),
+        };
+        const acquireTokenMeasurement = this.performanceClient.startMeasurement(PerformanceEvents.SilentRefreshClientAcquireToken, silentRequest.correlationId);
+        const serverTelemetryManager = this.initializeServerTelemetryManager(ApiId.acquireTokenSilent_silentFlow);
+        const refreshTokenClient = await this.createRefreshTokenClient(serverTelemetryManager, silentRequest.authority, silentRequest.azureCloudOptions);
+        this.logger.verbose("Refresh token client created");
+        // Send request to renew token. Auth module will throw errors if token cannot be renewed.
+        this.performanceClient.setPreQueueTime(PerformanceEvents.RefreshTokenClientAcquireTokenByRefreshToken, request.correlationId);
+        return refreshTokenClient
+            .acquireTokenByRefreshToken(silentRequest)
+            .then((result) => {
+            acquireTokenMeasurement.endMeasurement({
+                success: true,
+                fromCache: result.fromCache,
+                requestId: result.requestId,
+            });
+            return result;
+        })
+            .catch((e) => {
+            e.setCorrelationId(this.correlationId);
+            serverTelemetryManager.cacheFailedRequest(e);
+            acquireTokenMeasurement.endMeasurement({
+                errorCode: e.errorCode,
+                subErrorCode: e.subError,
+                success: false,
+            });
+            throw e;
+        });
+    }
+    /**
+     * Currently Unsupported
+     */
+    logout() {
+        // Synchronous so we must reject
+        return Promise.reject(BrowserAuthError.createSilentLogoutUnsupportedError());
+    }
+    /**
+     * Creates a Refresh Client with the given authority, or the default authority.
+     * @param serverTelemetryManager
+     * @param authorityUrl
+     */
+    async createRefreshTokenClient(serverTelemetryManager, authorityUrl, azureCloudOptions) {
+        // Create auth module.
+        this.performanceClient.setPreQueueTime(PerformanceEvents.StandardInteractionClientGetClientConfiguration, this.correlationId);
+        const clientConfig = await this.getClientConfiguration(serverTelemetryManager, authorityUrl, azureCloudOptions);
+        return new RefreshTokenClient(clientConfig, this.performanceClient);
+    }
 }
 
 export { SilentRefreshClient };

package/dist/interaction_client/StandardInteractionClient.d.ts

@@ -1,60 +1,60 @@
-import { ServerTelemetryManager, CommonAuthorizationCodeRequest, AuthorizationCodeClient, ClientConfiguration, Authority, ServerAuthorizationCodeResponse, CommonEndSessionRequest, AccountInfo, AzureCloudOptions } from "@azure/msal-common";
-import { BaseInteractionClient } from "./BaseInteractionClient";
-import { AuthorizationUrlRequest } from "../request/AuthorizationUrlRequest";
-import { InteractionType } from "../utils/BrowserConstants";
-import { EndSessionRequest } from "../request/EndSessionRequest";
-import { RedirectRequest } from "../request/RedirectRequest";
-import { PopupRequest } from "../request/PopupRequest";
-import { SsoSilentRequest } from "../request/SsoSilentRequest";
-/**
- * Defines the class structure and helper functions used by the "standard", non-brokered auth flows (popup, redirect, silent (RT), silent (iframe))
- */
-export declare abstract class StandardInteractionClient extends BaseInteractionClient {
-    /**
-     * Generates an auth code request tied to the url request.
-     * @param request
-     */
-    protected initializeAuthorizationCodeRequest(request: AuthorizationUrlRequest): Promise<CommonAuthorizationCodeRequest>;
-    /**
-     * Initializer for the logout request.
-     * @param logoutRequest
-     */
-    protected initializeLogoutRequest(logoutRequest?: EndSessionRequest): CommonEndSessionRequest;
-    /**
-     * Parses login_hint ID Token Claim out of AccountInfo object to be used as
-     * logout_hint in end session request.
-     * @param account
-     */
-    protected getLogoutHintFromIdTokenClaims(account: AccountInfo): string | null;
-    /**
-     * Creates an Authorization Code Client with the given authority, or the default authority.
-     * @param serverTelemetryManager
-     * @param authorityUrl
-     */
-    protected createAuthCodeClient(serverTelemetryManager: ServerTelemetryManager, authorityUrl?: string, requestAzureCloudOptions?: AzureCloudOptions): Promise<AuthorizationCodeClient>;
-    /**
-     * Creates a Client Configuration object with the given request authority, or the default authority.
-     * @param serverTelemetryManager
-     * @param requestAuthority
-     * @param requestCorrelationId
-     */
-    protected getClientConfiguration(serverTelemetryManager: ServerTelemetryManager, requestAuthority?: string, requestAzureCloudOptions?: AzureCloudOptions): Promise<ClientConfiguration>;
-    /**
-     * @param hash
-     * @param interactionType
-     */
-    protected validateAndExtractStateFromHash(serverParams: ServerAuthorizationCodeResponse, interactionType: InteractionType, requestCorrelationId?: string): string;
-    /**
-     * Used to get a discovered version of the default authority.
-     * @param requestAuthority
-     * @param requestCorrelationId
-     */
-    protected getDiscoveredAuthority(requestAuthority?: string, requestAzureCloudOptions?: AzureCloudOptions): Promise<Authority>;
-    /**
-     * Helper to initialize required request parameters for interactive APIs and ssoSilent()
-     * @param request
-     * @param interactionType
-     */
-    protected initializeAuthorizationRequest(request: RedirectRequest | PopupRequest | SsoSilentRequest, interactionType: InteractionType): Promise<AuthorizationUrlRequest>;
-}
+import { ServerTelemetryManager, CommonAuthorizationCodeRequest, AuthorizationCodeClient, ClientConfiguration, Authority, ServerAuthorizationCodeResponse, CommonEndSessionRequest, AccountInfo, AzureCloudOptions } from "@azure/msal-common";
+import { BaseInteractionClient } from "./BaseInteractionClient";
+import { AuthorizationUrlRequest } from "../request/AuthorizationUrlRequest";
+import { InteractionType } from "../utils/BrowserConstants";
+import { EndSessionRequest } from "../request/EndSessionRequest";
+import { RedirectRequest } from "../request/RedirectRequest";
+import { PopupRequest } from "../request/PopupRequest";
+import { SsoSilentRequest } from "../request/SsoSilentRequest";
+/**
+ * Defines the class structure and helper functions used by the "standard", non-brokered auth flows (popup, redirect, silent (RT), silent (iframe))
+ */
+export declare abstract class StandardInteractionClient extends BaseInteractionClient {
+    /**
+     * Generates an auth code request tied to the url request.
+     * @param request
+     */
+    protected initializeAuthorizationCodeRequest(request: AuthorizationUrlRequest): Promise<CommonAuthorizationCodeRequest>;
+    /**
+     * Initializer for the logout request.
+     * @param logoutRequest
+     */
+    protected initializeLogoutRequest(logoutRequest?: EndSessionRequest): CommonEndSessionRequest;
+    /**
+     * Parses login_hint ID Token Claim out of AccountInfo object to be used as
+     * logout_hint in end session request.
+     * @param account
+     */
+    protected getLogoutHintFromIdTokenClaims(account: AccountInfo): string | null;
+    /**
+     * Creates an Authorization Code Client with the given authority, or the default authority.
+     * @param serverTelemetryManager
+     * @param authorityUrl
+     */
+    protected createAuthCodeClient(serverTelemetryManager: ServerTelemetryManager, authorityUrl?: string, requestAzureCloudOptions?: AzureCloudOptions): Promise<AuthorizationCodeClient>;
+    /**
+     * Creates a Client Configuration object with the given request authority, or the default authority.
+     * @param serverTelemetryManager
+     * @param requestAuthority
+     * @param requestCorrelationId
+     */
+    protected getClientConfiguration(serverTelemetryManager: ServerTelemetryManager, requestAuthority?: string, requestAzureCloudOptions?: AzureCloudOptions): Promise<ClientConfiguration>;
+    /**
+     * @param hash
+     * @param interactionType
+     */
+    protected validateAndExtractStateFromHash(serverParams: ServerAuthorizationCodeResponse, interactionType: InteractionType, requestCorrelationId?: string): string;
+    /**
+     * Used to get a discovered version of the default authority.
+     * @param requestAuthority
+     * @param requestCorrelationId
+     */
+    protected getDiscoveredAuthority(requestAuthority?: string, requestAzureCloudOptions?: AzureCloudOptions): Promise<Authority>;
+    /**
+     * Helper to initialize required request parameters for interactive APIs and ssoSilent()
+     * @param request
+     * @param interactionType
+     */
+    protected initializeAuthorizationRequest(request: RedirectRequest | PopupRequest | SsoSilentRequest, interactionType: InteractionType): Promise<AuthorizationUrlRequest>;
+}
 //# sourceMappingURL=StandardInteractionClient.d.ts.map