@equinor/fusion-framework-module-msal 5.1.2 → 6.0.0-next.1

package/dist/types/MsalProvider.interface.d.ts

@@ -0,0 +1,159 @@
+import type { AcquireTokenOptions, AcquireTokenResult, IMsalClient, LoginOptions, LoginResult, LogoutOptions } from './MsalClient.interface';
+import type { IProxyProvider } from './MsalProxyProvider.interface';
+import type { AccountInfo, AuthenticationResult } from './types';
+/**
+ * Legacy token acquisition options maintaining backward compatibility.
+ *
+ * This type extends `AcquireTokenOptions` with an optional `scopes` property
+ * to support legacy API calls that passed scopes directly rather than in the request object.
+ *
+ * @property scopes - Optional array of OAuth scopes (deprecated, use request.scopes)
+ *
+ * @deprecated Use the modern format with scopes in the request object instead
+ * @example
+ * ```typescript
+ * // Deprecated legacy format
+ * acquireToken({ scopes: ['User.Read'] })
+ *
+ * // Modern format (preferred)
+ * acquireToken({ request: { scopes: ['User.Read'] } })
+ * ```
+ */
+export type AcquireTokenOptionsLegacy = AcquireTokenOptions & {
+    scopes?: string[];
+};
+/**
+ * Interface for MSAL v4 authentication provider.
+ *
+ * This interface defines the contract for authentication providers that work
+ * with Microsoft Authentication Library v4, providing a unified API for
+ * token acquisition, user authentication, and account management.
+ *
+ * @example
+ * ```typescript
+ * const provider: IMsalProvider = new MsalProvider(config);
+ *
+ * // Login user (v4 format)
+ * await provider.login({ request: { scopes: ['User.Read'] } });
+ *
+ * // Acquire token (v4 format - recommended)
+ * const token = await provider.acquireAccessToken({
+ *   request: { scopes: ['https://graph.microsoft.com/.default'] }
+ * });
+ * ```
+ */
+export interface IMsalProvider extends IProxyProvider {
+    /**
+     * The MSAL PublicClientApplication client instance.
+     *
+     * Provides access to the underlying MSAL client for advanced use cases.
+     * Use provider methods for standard authentication operations.
+     */
+    readonly client: IMsalClient;
+    /**
+     * The currently authenticated account information.
+     *
+     * Returns the active account if available, or null if no user is authenticated.
+     */
+    readonly account: AccountInfo | null;
+    /**
+     * Initializes the MSAL provider and handles authentication state.
+     *
+     * This method must be called before using other provider methods. It:
+     * - Initializes the MSAL client
+     * - Processes any pending authentication redirects
+     * - Attempts automatic login if requiresAuth is enabled
+     *
+     * @returns Promise that resolves when initialization is complete
+     */
+    initialize(): Promise<void>;
+    /**
+     * Acquires an access token string for the specified scopes.
+     *
+     * This is a convenience method that returns only the access token string,
+     * unlike `acquireToken` which returns the full authentication result.
+     *
+     * @param options - Token acquisition options including scopes
+     * @returns Promise resolving to the access token string, or undefined if acquisition fails
+     *
+     * @example
+     * ```typescript
+     * const token = await provider.acquireAccessToken({
+     *   request: { scopes: ['User.Read'] }
+     * });
+     * ```
+     */
+    acquireAccessToken(options: AcquireTokenOptionsLegacy): Promise<string | undefined>;
+    /**
+     * Acquires a full authentication result including token and account information.
+     *
+     * This method attempts silent token acquisition first, then falls back to interactive
+     * authentication based on the configured behavior (popup or redirect).
+     *
+     * @param options - Token acquisition options including scopes
+     * @returns Promise resolving to full authentication result or null/undefined on failure
+     *
+     * @example
+     * ```typescript
+     * const result = await provider.acquireToken({
+     *   request: { scopes: ['User.Read'] },
+     *   behavior: 'popup'
+     * });
+     * ```
+     */
+    acquireToken(options: AcquireTokenOptionsLegacy): Promise<AcquireTokenResult>;
+    /**
+     * Authenticates a user interactively with Microsoft Identity Platform.
+     *
+     * This method implements a sophisticated flow that attempts silent authentication
+     * first (if configured) and falls back to interactive authentication based on behavior.
+     *
+     * @param options - Login configuration options including request, behavior, and silent flag
+     * @returns Promise resolving to authentication result or undefined for redirect flows
+     *
+     * @example
+     * ```typescript
+     * // Basic login with default settings
+     * await provider.login({ request: { scopes: ['User.Read'] } });
+     * ```
+     */
+    login(options: LoginOptions): Promise<LoginResult>;
+    /**
+     * Logs out the current user and clears authentication state.
+     *
+     * Initiates a logout flow that clears local tokens and navigates to Microsoft's
+     * logout endpoint. Always uses redirect flow for reliability.
+     *
+     * @param options - Optional logout configuration
+     * @returns Promise resolving to true on success, false on failure
+     *
+     * @example
+     * ```typescript
+     * // Basic logout
+     * await provider.logout();
+     *
+     * // Logout with redirect
+     * await provider.logout({ redirectUri: 'https://app.com/logout' });
+     * ```
+     */
+    logout(options?: LogoutOptions): Promise<boolean>;
+    /**
+     * Processes any pending authentication redirect after browser navigation.
+     *
+     * This method must be called on app initialization to handle authentication
+     * results from redirect-based flows. It processes tokens and account information
+     * returned by Microsoft's identity provider.
+     *
+     * @returns Promise resolving to authentication result or null if no redirect pending
+     *
+     * @example
+     * ```typescript
+     * // Call on app startup
+     * const result = await provider.handleRedirect();
+     * if (result?.account) {
+     *   // User successfully authenticated via redirect
+     * }
+     * ```
+     */
+    handleRedirect(): Promise<AuthenticationResult | null>;
+}

package/dist/types/MsalProxyProvider.interface.d.ts

@@ -0,0 +1,52 @@
+import type { SemVer } from 'semver';
+import type { MsalModuleVersion } from './static';
+/**
+ * Interface for providers that can create version-compatible proxy providers.
+ *
+ * This interface enables backward compatibility by allowing providers to create
+ * proxies that adapt their API to match different MSAL version signatures. The proxy
+ * wraps the v4 implementation and exposes it through older version interfaces.
+ *
+ * @remarks
+ * This interface should ideally be defined in the @equinor/fusion-framework-module package
+ * for broader framework compatibility.
+ *
+ * @property version - The semantic version of the provider
+ * @property msalVersion - The MSAL module version enum value
+ * @property createProxyProvider - Method to create a version-specific proxy provider
+ *
+ * @example
+ * ```typescript
+ * const provider: IMsalProvider = new MsalProvider(config);
+ *
+ * // Create a v2-compatible proxy
+ * const v2Proxy = provider.createProxyProvider('2.0.0');
+ * // v2Proxy now has v2-compatible method signatures
+ * ```
+ */
+export interface IProxyProvider {
+    /**
+     * The semantic version of the provider.
+     *
+     * This represents the actual version number of the MSAL implementation,
+     * following semantic versioning (semver) standards.
+     */
+    readonly version: string | SemVer;
+    /**
+     * The MSAL module version enum value indicating the API compatibility level.
+     *
+     * This property specifies which MSAL version's API surface this provider implements,
+     * allowing for version-specific behavior and proxy provider creation.
+     */
+    msalVersion: MsalModuleVersion;
+    /**
+     * Creates a proxy provider compatible with the specified MSAL version.
+     *
+     * The proxy adapts the provider's v4 API to match the requested version's interface,
+     * enabling backward compatibility during migration scenarios.
+     *
+     * @param version - Target version key (V2, V4, or Latest)
+     * @returns Proxy provider with version-specific type
+     */
+    createProxyProvider<T extends keyof ProxyProviderMap>(version: T): ProxyProviderMap[T];
+}

package/dist/types/create-client-log-callback.d.ts

@@ -0,0 +1,38 @@
+import { type ILoggerCallback } from '@azure/msal-browser';
+import { type ITelemetryProvider } from '@equinor/fusion-framework-module-telemetry';
+/**
+ * Creates a telemetry callback function for MSAL logging integration.
+ *
+ * This function bridges MSAL's internal logging system with the framework's
+ * telemetry infrastructure. It maps MSAL log levels to telemetry levels and
+ * forwards log events to the provided telemetry provider with structured metadata.
+ *
+ * The callback function returned by this method will be called by MSAL whenever
+ * a log event occurs, allowing for centralized logging and monitoring of
+ * authentication-related events.
+ *
+ * @param provider - Telemetry provider instance to receive log events
+ * @param metadata - Additional metadata to include with each telemetry event (e.g., module version, environment)
+ * @param scope - Telemetry scope identifiers for categorization and filtering
+ * @returns Logger callback function for MSAL that forwards events to telemetry provider
+ *
+ * @example
+ * ```typescript
+ * const callback = createClientLogCallback(
+ *   telemetryProvider,
+ *   { module: 'msal', version: '4.0.0' },
+ *   ['framework', 'authentication']
+ * );
+ *
+ * // Use with MSAL configuration
+ * const config = {
+ *   system: {
+ *     loggerOptions: {
+ *       loggerCallback: callback,
+ *       piiLoggingEnabled: false
+ *     }
+ *   }
+ * };
+ * ```
+ */
+export declare const createClientLogCallback: (provider: ITelemetryProvider, metadata: Record<string, unknown>, scope: string[]) => ILoggerCallback | undefined;

package/dist/types/create-proxy-provider.d.ts

@@ -0,0 +1,19 @@
+import type { IMsalProvider } from './MsalProvider.interface';
+/**
+ * Creates a proxy provider for version compatibility.
+ *
+ * This function handles the creation of proxy providers that maintain
+ * backward compatibility with different MSAL versions while using the
+ * latest MSAL v4 implementation under the hood.
+ *
+ * @param provider - The base MSAL provider instance
+ * @param version - The target version string (e.g., '2.0.0', '4.0.0')
+ * @returns A proxy provider compatible with the specified version
+ *
+ * @example
+ * ```typescript
+ * const baseProvider = new MsalProvider(config);
+ * const v2Proxy = createProxyProvider(baseProvider, '2.0.0');
+ * ```
+ */
+export declare function createProxyProvider<T = IMsalProvider>(provider: IMsalProvider, version: string): T;

package/dist/types/index.d.ts

@@ -1,5 +1,6 @@
-export { module, configureMsal, enableMSAL, type AuthConfigurator as IAppConfigurator, type AuthConfigFn, type IAuthProvider, type MsalModule, } from './module';
-export { MsalModuleVersion } from './static';
+export { module, configureMsal, enableMSAL, type MsalModule, type AuthConfigFn, } from './module';
+export type { IMsalProvider } from './MsalProvider.interface';
+export type { IMsalClient } from './MsalClient.interface';
+export { MsalClient, type MsalClientConfig } from './MsalClient';
+export type { AccountInfo, AuthenticationResult } from './types';
 export { default } from './module';
-export type { AccountInfo, AuthenticationResult } from './v2/types';
-export type { AuthClientConfig } from './v2/configurator';

package/dist/types/module.d.ts

@@ -1,13 +1,79 @@
 import { type Module, type IModulesConfigurator } from '@equinor/fusion-framework-module';
-import { AuthConfigurator, type AuthClientConfig, type IAuthProvider } from './v2';
-export type MsalModule = Module<'auth', IAuthProvider, AuthConfigurator, [MsalModule]>;
-export type { AuthConfigurator, IAuthProvider };
+import { MsalConfigurator } from './MsalConfigurator';
+import { type IMsalProvider } from './MsalProvider';
+import type { MsalClientConfig } from './MsalClient';
+/**
+ * MSAL authentication module configuration.
+ *
+ * This module provides Microsoft Authentication Library (MSAL) integration for the
+ * Fusion Framework, supporting MSAL v4 with backward compatibility for v2 applications.
+ */
+export type MsalModule = Module<'auth', IMsalProvider, MsalConfigurator, [MsalModule]>;
+/**
+ * MSAL authentication module definition.
+ *
+ * This module manages authentication providers with the following initialization flow:
+ * 1. Check for custom provider configuration
+ * 2. Check for existing provider in parent module (for proxy compatibility)
+ * 3. Create new provider with client configuration
+ *
+ * @remarks
+ * The module supports proxy providers for version compatibility, allowing v4 implementations
+ * to work with v2-compatible code during migration periods.
+ */
 export declare const module: MsalModule;
+/**
+ * Configuration function type for MSAL module setup.
+ *
+ * This function receives a builder object with methods to configure the MSAL client
+ * and authentication requirements.
+ */
 export type AuthConfigFn = (builder: {
-    setClientConfig: (config: AuthClientConfig) => void;
+    /**
+     * Set MSAL client configuration
+     * @param config - Client configuration with tenant ID, client ID, etc.
+     */
+    setClientConfig: (config: MsalClientConfig) => void;
+    /**
+     * Set whether authentication is required for the application
+     * @param requiresAuth - If true, app will attempt automatic login on initialization
+     */
     setRequiresAuth: (requiresAuth: boolean) => void;
 }) => void;
+/**
+ * Enables MSAL authentication module in the framework.
+ *
+ * This is a convenience function that adds the MSAL module configuration to the
+ * framework configurator with optional configuration callback.
+ *
+ * @param configurator - The framework modules configurator instance
+ * @param configure - Optional configuration callback for MSAL setup
+ *
+ * @example
+ * ```typescript
+ * enableMSAL(frameworkConfigurator, (builder) => {
+ *   builder.setClientConfig({
+ *     auth: { clientId: 'your-client-id', tenantId: 'your-tenant-id' }
+ *   });
+ *   builder.setRequiresAuth(true);
+ * });
+ * ```
+ */
 export declare const enableMSAL: (configurator: IModulesConfigurator<any, any>, configure?: AuthConfigFn) => void;
+/**
+ * Creates MSAL module configuration with custom setup.
+ *
+ * @param configure - Configuration callback function
+ * @returns Module configuration object ready for framework integration
+ *
+ * @example
+ * ```typescript
+ * const msalConfig = configureMsal((builder) => {
+ *   builder.setClientConfig(msalClientConfig);
+ *   builder.setRequiresAuth(true);
+ * });
+ * ```
+ */
 export declare const configureMsal: (configure: AuthConfigFn) => {
     module: MsalModule;
     configure: AuthConfigFn;

package/dist/types/static.d.ts

@@ -1,5 +1,36 @@
+/**
+ * Module identifier for the MSAL authentication module.
+ *
+ * This constant is used to register and identify the MSAL module within the Fusion Framework.
+ */
 export declare const ModuleName: "msal";
+/**
+ * Enumeration of supported MSAL module versions.
+ *
+ * This enum defines the available MSAL versions and provides type-safe access to version identifiers.
+ * The `Latest` value is automatically set to the current module version at build time.
+ *
+ * @remarks
+ * - `V2`: MSAL v2 compatibility (legacy support)
+ * - `V4`: MSAL v4 (current major version)
+ * - `Latest`: Always points to the current module version (5.1.0)
+ *
+ * @example
+ * ```typescript
+ * import { MsalModuleVersion } from '@equinor/fusion-framework-module-msal';
+ *
+ * // Check version
+ * if (version === MsalModuleVersion.Latest) {
+ *   console.log('Using latest MSAL version');
+ * }
+ *
+ * // Create version-specific proxy
+ * const proxy = provider.createProxyProvider(MsalModuleVersion.V2);
+ * ```
+ */
 export declare enum MsalModuleVersion {
+    /** MSAL v2 compatibility version */
     V2 = "v2",
-    Latest = "5.1.2"
+    /** MSAL v4 (current major version) */
+    V4 = "v4"
 }

package/dist/types/types.d.ts

@@ -1,6 +1,14 @@
-import type { SemVer } from 'semver';
-import type { MsalModuleVersion } from './static';
-export interface IProxyProvider {
-    version: string | SemVer;
-    createProxyProvider<T>(version: MsalModuleVersion): T;
-}
+/**
+ * Re-exports of core MSAL types from @azure/msal-browser.
+ *
+ * This module provides convenient access to commonly used MSAL types without
+ * requiring direct imports from @azure/msal-browser. These types represent
+ * fundamental authentication entities used throughout the MSAL module.
+ *
+ * @module
+ */
+export { 
+/** Represents account information for an authenticated user */
+AccountInfo, 
+/** Represents the result of an authentication operation including tokens and account */
+AuthenticationResult, } from '@azure/msal-browser';

package/dist/types/util/redirect.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/v2/IAuthClient.interface.d.ts

@@ -0,0 +1,68 @@
+import type { AuthenticationResult, AccountInfo as AccountInfoBase, IPublicClientApplication } from '@azure/msal-browser';
+export type IdTokenClaims = {
+    aud: string;
+    exp: number;
+};
+export type AccountInfo = AccountInfoBase & {
+    idTokenClaims?: IdTokenClaims;
+};
+export type AuthBehavior = 'popup' | 'redirect';
+export type AuthRequest = {
+    scopes?: string[];
+    loginHint?: string;
+};
+/**
+ * Interface for MSAL v2 compatible authentication client.
+ *
+ * This interface defines the contract for authentication clients that maintain
+ * backward compatibility with MSAL v2 API while using MSAL v4 implementation
+ * under the hood. This is useful for gradual migration scenarios.
+ *
+ * @example
+ * ```typescript
+ * const client: IAuthClient_v2 = createProxyClient(baseClient);
+ *
+ * // Use v2 compatible API
+ * const account = client.account;
+ * const result = await client.login({ scopes: ['User.Read'] });
+ * ```
+ */
+export interface IAuthClient extends IPublicClientApplication {
+    /**
+     * Tenant ID for the client domain
+     */
+    readonly tenantId: string;
+    /**
+     * Returns account for client tenant that MSAL currently has data for.
+     * (the account object is created at the time of successful login)
+     */
+    get account(): AccountInfo | undefined;
+    /**
+     * Check if the current account has valid claims
+     */
+    get hasValidClaims(): boolean;
+    /**
+     * Configured client ID
+     */
+    get clientId(): string | undefined;
+    /**
+     * Request origin from browser storage
+     */
+    get requestOrigin(): string | null;
+    /**
+     * Login user with optional silent authentication fallback
+     * @param options - Optional authentication request options
+     * @param behavior - Authentication method: 'popup' or 'redirect'
+     * @param silent - Whether to attempt silent authentication first
+     * @returns Promise resolving to authentication result or void
+     */
+    login(options?: AuthRequest, behavior?: AuthBehavior, silent?: boolean): Promise<AuthenticationResult | void>;
+    /**
+     * Acquire access token with optional silent authentication fallback
+     * @param options - Authentication request options
+     * @param behavior - Authentication method: 'popup' or 'redirect'
+     * @param silent - Whether to attempt silent authentication first
+     * @returns Promise resolving to authentication result or void
+     */
+    acquireToken(options?: AuthRequest, behavior?: AuthBehavior, silent?: boolean): Promise<AuthenticationResult | void>;
+}

package/dist/types/v2/IPublicClientApplication.interface.d.ts

@@ -0,0 +1,68 @@
+import type { AccountInfo, AuthenticationResult } from './types';
+/**
+ * MSAL v2 compatible PublicClientApplication interface.
+ *
+ * This interface defines the contract for MSAL v2 PublicClientApplication
+ * to maintain backward compatibility while using MSAL v4 implementation.
+ *
+ * @example
+ * ```typescript
+ * const v4Client = new PublicClientApplication(config);
+ * const v2Client = createProxyClient_v2(v4Client);
+ *
+ * // Use v2-compatible methods
+ * const accounts = v2Client.getAllAccounts();
+ * const token = await v2Client.acquireTokenSilent({ scopes: ['User.Read'], account });
+ * ```
+ */
+export interface IPublicClientApplication {
+    /**
+     * Get all cached accounts
+     * @returns Array of cached account information
+     */
+    getAllAccounts(): AccountInfo[];
+    /**
+     * Acquire token silently using cached credentials
+     * @param request - Token request parameters
+     * @returns Promise resolving to authentication result
+     */
+    acquireTokenSilent(request: {
+        scopes: string[];
+        account: AccountInfo;
+    }): Promise<AuthenticationResult>;
+    /**
+     * Login user via popup window
+     * @param request - Optional login request parameters
+     * @returns Promise resolving to authentication result
+     */
+    loginPopup(request?: {
+        scopes?: string[];
+    }): Promise<AuthenticationResult>;
+    /**
+     * Login user via redirect
+     * @param request - Optional login request parameters
+     * @returns Promise that resolves when redirect is initiated
+     */
+    loginRedirect(request?: {
+        scopes?: string[];
+    }): Promise<void>;
+    /**
+     * Logout user via redirect
+     * @param request - Optional logout request parameters
+     * @returns Promise that resolves when logout is complete
+     */
+    logoutRedirect(request?: {
+        postLogoutRedirectUri?: string;
+        account?: AccountInfo;
+    }): Promise<void>;
+    /**
+     * Handle authentication redirect after login/logout
+     * @returns Promise resolving to authentication result or null
+     */
+    handleRedirectPromise(): Promise<AuthenticationResult | null>;
+    /**
+     * Get the currently active account
+     * @returns Active account information or null
+     */
+    getActiveAccount(): AccountInfo | null;
+}

package/dist/types/v2/MsalProvider.interface.d.ts

@@ -0,0 +1,85 @@
+import type { SemVer } from 'semver';
+import type { MsalModuleVersion } from '../static';
+import type { IPublicClientApplication } from './IPublicClientApplication.interface';
+import type { AccountInfo, AuthenticationResult } from './types';
+/**
+ * Interface for MSAL v2 compatible authentication provider.
+ *
+ * This interface defines the contract for authentication providers that maintain
+ * backward compatibility with MSAL v2 API while using MSAL v4 implementation
+ * under the hood. This is useful for gradual migration scenarios.
+ */
+export interface IMsalProvider {
+    /** Current version of the provider (MSAL module version) */
+    version: string | SemVer;
+    /** Current MSAL module version */
+    msalVersion: MsalModuleVersion;
+    /**
+     * The MSAL PublicClientApplication instance (v2 compatible)
+     */
+    readonly client: IPublicClientApplication;
+    /**
+     * The current authenticated account (v2 compatibility)
+     * @deprecated Use activeAccount instead
+     */
+    readonly defaultAccount: AccountInfo | undefined;
+    /**
+     * The client configuration used to initialize this provider
+     * @deprecated Configuration should not be exposed
+     */
+    readonly defaultConfig: unknown | undefined;
+    /**
+     * The MSAL client instance (v2 compatibility)
+     * @deprecated Use client instead
+     */
+    readonly defaultClient: IPublicClientApplication;
+    /**
+     * Create a new MSAL client instance
+     * @deprecated This method is deprecated in MSAL v4
+     */
+    createClient(): IPublicClientApplication;
+    /**
+     * Acquire an access token for the specified scopes
+     * @param req - Auth request options (v2 compatible)
+     */
+    acquireAccessToken(req: {
+        scopes: string[];
+        account?: AccountInfo;
+    }): Promise<string | undefined>;
+    /**
+     * Acquire full authentication result
+     * @param req - Auth request options (v2 compatible)
+     */
+    acquireToken(req: {
+        scopes: string[];
+        account?: AccountInfo;
+    }): Promise<AuthenticationResult | undefined>;
+    /**
+     * Login user interactively
+     * @param options - Login options (v2 compatible)
+     */
+    login(options?: {
+        onlyIfRequired?: boolean;
+    }): Promise<void>;
+    /**
+     * Logout user
+     * @param options - Logout options (v2 compatible)
+     */
+    logout(options?: {
+        redirectUri?: string;
+    }): Promise<void>;
+    /**
+     * Handle authentication redirect
+     */
+    handleRedirect(): Promise<void | null>;
+    /**
+     * Create a proxy provider for version compatibility
+     * @param version - Version string
+     * @returns Proxy provider
+     */
+    createProxyProvider<T = IMsalProvider>(version: string): T;
+    /**
+     * Dispose of the provider and clean up resources
+     */
+    dispose(): void;
+}

package/dist/types/v2/create-proxy-client.d.ts

@@ -0,0 +1,22 @@
+import type { IMsalClient } from '../MsalClient.interface';
+import type { IAuthClient } from './IAuthClient.interface';
+/**
+ * Creates a v2-compatible proxy for MSAL PublicClientApplication.
+ *
+ * This function creates a proxy that wraps the MSAL v4 PublicClientApplication
+ * and provides v2-compatible method signatures and return types.
+ *
+ * @param client - The MSAL v4 PublicClientApplication instance
+ * @returns A proxy client with v2-compatible interface
+ *
+ * @example
+ * ```typescript
+ * const v4Client = new PublicClientApplication(config);
+ * const v2Client = createProxyClient_v2(v4Client);
+ *
+ * // Use v2-compatible methods
+ * const accounts = v2Client.getAllAccounts();
+ * const token = await v2Client.acquireTokenSilent({ scopes: ['User.Read'], account });
+ * ```
+ */
+export declare function createProxyClient(client: IMsalClient): IAuthClient;