import { ICrypto, Logger, AuthorizationCodeClient, IPerformanceClient, CommonAuthorizationUrlRequest } from "@azure/msal-common/browser";
import { StandardInteractionClient } from "./StandardInteractionClient.js";
import { BrowserConfiguration } from "../config/Configuration.js";
import { BrowserCacheManager } from "../cache/BrowserCacheManager.js";
import { EventHandler } from "../event/EventHandler.js";
import { INavigationClient } from "../navigation/INavigationClient.js";
import { ApiId } from "../utils/BrowserConstants.js";
import { SsoSilentRequest } from "../request/SsoSilentRequest.js";
import { AuthenticationResult } from "../response/AuthenticationResult.js";
import { IPlatformAuthHandler } from "../broker/nativeBroker/IPlatformAuthHandler.js";
import type { WaitForBridgeRequest } from "../utils/BrowserUtils.js";
/**
 * Minimal request shape accepted by the iframe-response hook.
 * Intentionally narrow so subclasses can override without needing
 * access to internal resolved-request types.
 *
 * @internal
 */
export type WaitForIframeRequest = WaitForBridgeRequest;
/**
 * Signature of the iframe-response handler supplied by
 * {@link PublicClientApplication} to {@link SilentIframeClient} via the
 * operating context.
 *
 * @internal
 */
export type WaitForIframeResponseFn = (iframe: HTMLIFrameElement, request: WaitForIframeRequest) => Promise<string>;
export declare class SilentIframeClient extends StandardInteractionClient {
    protected apiId: ApiId;
    protected nativeStorage: BrowserCacheManager;
    private readonly waitForIframeResponseHook;
    constructor(config: BrowserConfiguration, storageImpl: BrowserCacheManager, browserCrypto: ICrypto, logger: Logger, eventHandler: EventHandler, navigationClient: INavigationClient, apiId: ApiId, performanceClient: IPerformanceClient, nativeStorageImpl: BrowserCacheManager, correlationId: string, platformAuthProvider?: IPlatformAuthHandler, waitForIframeResponseHook?: WaitForIframeResponseFn);
    /**
     * Acquires a token silently by opening a hidden iframe to the /authorize endpoint with prompt=none or prompt=no_session
     * @param request
     */
    acquireToken(request: SsoSilentRequest): Promise<AuthenticationResult>;
    /**
     * Executes auth code + PKCE flow
     * @param request
     * @returns
     */
    executeCodeFlow(request: CommonAuthorizationUrlRequest): Promise<AuthenticationResult>;
    /**
     * Executes EAR flow
     * @param request
     */
    executeEarFlow(request: CommonAuthorizationUrlRequest): Promise<AuthenticationResult>;
    /**
     * Verifies SSO capability by making an iframe request to /authorize without exchanging the code for tokens.
     * This is useful for verifying SSO capability in the background without the overhead of a full token exchange.
     * @param request - The SSO silent request
     * @returns true if SSO verification was successful with a valid authorization code, false otherwise
     */
    verifySso(request: SsoSilentRequest): Promise<boolean>;
    /**
     * Currently Unsupported
     */
    logout(): Promise<void>;
    /**
     * 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
     */
    protected silentTokenHelper(authClient: AuthorizationCodeClient, request: CommonAuthorizationUrlRequest): Promise<AuthenticationResult>;
    /**
     * Shared helper that generates PKCE codes, builds the /authorize URL,
     * loads it in a hidden iframe, waits for the redirect-bridge response,
     * and returns the deserialized server parameters along with the PKCE codes
     * and the request that was sent.
     */
    private silentAuthorizeHelper;
    protected waitForIframeResponse(iframe: HTMLIFrameElement, request: WaitForIframeRequest): Promise<string>;
}
//# sourceMappingURL=SilentIframeClient.d.ts.map