@azure/msal-common 1.6.3 → 2.0.0

package/dist/src/account/AccountInfo.d.ts

@@ -4,12 +4,17 @@
  * - environment            - Entity which issued the token represented by the domain of the issuer (e.g. login.microsoftonline.com)
  * - tenantId               - Full tenant or organizational id that this account belongs to
  * - username               - preferred_username claim of the id_token that represents this account
+ * - localAccountId         - Local, tenant-specific account identifer for this account object, usually used in legacy cases
  * - name                   - Full name for the account, including given name and family name
+ * - idTokenClaims          - Object contains claims from ID token
+ * - localAccountId         - The user's account ID
  */
 export declare type AccountInfo = {
     homeAccountId: string;
     environment: string;
     tenantId: string;
     username: string;
+    localAccountId: string;
     name?: string;
+    idTokenClaims?: object;
 };

package/dist/src/authority/Authority.d.ts

@@ -69,12 +69,19 @@ export declare class Authority {
      * @param openIdConfigurationEndpoint
      */
     private discoverEndpoints;
-    private get aadInstanceDiscoveryEndpointUrl();
+    /**
+     * Set the trusted hosts and validate subsequent calls
+     */
     private validateAndSetPreferredNetwork;
     /**
      * Perform endpoint discovery to discover the /authorize, /token and logout endpoints.
      */
     resolveEndpointsAsync(): Promise<void>;
+    /**
+     * Determine if given hostname is alias of this authority
+     * @param host
+     */
+    isAuthorityAlias(host: string): boolean;
     /**
      * helper function to generate environment from authority object
      * @param authority

package/dist/src/cache/CacheManager.d.ts

@@ -1,4 +1,4 @@
-import { AccountCache, AccountFilter, CredentialFilter, CredentialCache } from "./utils/CacheTypes";
+import { AccountCache, AccountFilter, CredentialFilter, CredentialCache, AppMetadataFilter, AppMetadataCache } from "./utils/CacheTypes";
 import { CacheRecord } from "./entities/CacheRecord";
 import { CredentialEntity } from "./entities/CredentialEntity";
 import { ScopeSet } from "../request/ScopeSet";
@@ -11,10 +11,14 @@ import { AccountInfo } from "../account/AccountInfo";
 import { AppMetadataEntity } from "./entities/AppMetadataEntity";
 import { ServerTelemetryEntity } from "./entities/ServerTelemetryEntity";
 import { ThrottlingEntity } from "./entities/ThrottlingEntity";
+import { ICrypto } from "../crypto/ICrypto";
 /**
  * Interface class which implement cache storage functions used by MSAL to perform validity checks, and store tokens.
  */
 export declare abstract class CacheManager implements ICacheManager {
+    protected clientId: string;
+    protected cryptoImpl: ICrypto;
+    constructor(clientId: string, cryptoImpl: ICrypto);
     /**
      * fetch the account entity from the platform cache
      *  @param accountKey
@@ -155,6 +159,17 @@ export declare abstract class CacheManager implements ICacheManager {
      * @param target
      */
     private getCredentialsFilteredByInternal;
+    /**
+     * retrieve appMetadata matching all provided filters; if no filter is set, get all appMetadata
+     * @param filter
+     */
+    getAppMetadataFilteredBy(filter: AppMetadataFilter): AppMetadataCache;
+    /**
+     * Support function to help match appMetadata
+     * @param environment
+     * @param clientId
+     */
+    private getAppMetadataFilteredByInternal;
     /**
      * Removes all accounts and related tokens from cache.
      */
@@ -216,7 +231,7 @@ export declare abstract class CacheManager implements ICacheManager {
     /**
      * Retrieve AppMetadataEntity from cache
      */
-    readAppMetadataFromCache(environment: string, clientId: string): AppMetadataEntity;
+    readAppMetadataFromCache(environment: string, clientId: string): AppMetadataEntity | null;
     /**
      * Return the family_id value associated  with FOCI
      * @param environment

package/dist/src/cache/entities/AccountEntity.d.ts

@@ -2,6 +2,9 @@ import { Authority } from "../../authority/Authority";
 import { AuthToken } from "../../account/AuthToken";
 import { ICrypto } from "../../crypto/ICrypto";
 import { AccountInfo } from "../../account/AccountInfo";
+import { AuthorityType } from "../../authority/AuthorityType";
+import { Logger } from "../../logger/Logger";
+import { TokenClaims } from "../../account/TokenClaims";
 /**
  * Type that defines required and optional parameters for an Account field (based on universal cache schema implemented by all MSALs).
  *
@@ -22,6 +25,7 @@ import { AccountInfo } from "../../account/AccountInfo";
  *      lastModificationTime: last time this entity was modified in the cache
  *      lastModificationApp:
  *      oboAssertion: access token passed in as part of OBO request
+ *      idTokenClaims: Object containing claims parsed from ID token
  * }
  */
 export declare class AccountEntity {
@@ -36,6 +40,9 @@ export declare class AccountEntity {
     lastModificationTime?: string;
     lastModificationApp?: string;
     oboAssertion?: string;
+    cloudGraphHostName?: string;
+    msGraphHost?: string;
+    idTokenClaims?: TokenClaims;
     /**
      * Generate Account Id key component as per the schema: <home_account_id>-<environment>
      */
@@ -64,13 +71,19 @@ export declare class AccountEntity {
      * @param idToken
      * @param policy
      */
-    static createAccount(clientInfo: string, authority: Authority, idToken: AuthToken, crypto: ICrypto, oboAssertion?: string): AccountEntity;
+    static createAccount(clientInfo: string, homeAccountId: string, authority: Authority, idToken: AuthToken, oboAssertion?: string, cloudGraphHostName?: string, msGraphHost?: string): AccountEntity;
     /**
      * Builds non-AAD/ADFS account.
      * @param authority
      * @param idToken
      */
-    static createGenericAccount(authority: Authority, idToken: AuthToken, oboAssertion?: string): AccountEntity;
+    static createGenericAccount(authority: Authority, homeAccountId: string, idToken: AuthToken, oboAssertion?: string, cloudGraphHostName?: string, msGraphHost?: string): AccountEntity;
+    /**
+     * Generate HomeAccountId from server response
+     * @param serverClientInfo
+     * @param authType
+     */
+    static generateHomeAccountId(serverClientInfo: string, authType: AuthorityType, logger: Logger, cryptoObj: ICrypto, idToken?: AuthToken): string;
     /**
      * Validates an entity: checks for all expected params
      * @param entity

package/dist/src/cache/entities/CacheRecord.d.ts

@@ -4,10 +4,10 @@ import { RefreshTokenEntity } from "./RefreshTokenEntity";
 import { AccountEntity } from "./AccountEntity";
 import { AppMetadataEntity } from "./AppMetadataEntity";
 export declare class CacheRecord {
-    account: AccountEntity;
-    idToken: IdTokenEntity;
-    accessToken: AccessTokenEntity;
-    refreshToken: RefreshTokenEntity;
-    appMetadata: AppMetadataEntity;
-    constructor(accountEntity?: AccountEntity, idTokenEntity?: IdTokenEntity, accessTokenEntity?: AccessTokenEntity, refreshTokenEntity?: RefreshTokenEntity, appMetadataEntity?: AppMetadataEntity);
+    account: AccountEntity | null;
+    idToken: IdTokenEntity | null;
+    accessToken: AccessTokenEntity | null;
+    refreshToken: RefreshTokenEntity | null;
+    appMetadata: AppMetadataEntity | null;
+    constructor(accountEntity?: AccountEntity | null, idTokenEntity?: IdTokenEntity | null, accessTokenEntity?: AccessTokenEntity | null, refreshTokenEntity?: RefreshTokenEntity | null, appMetadataEntity?: AppMetadataEntity | null);
 }

package/dist/src/client/AuthorizationCodeClient.d.ts

@@ -4,6 +4,7 @@ import { AuthorizationCodeRequest } from "../request/AuthorizationCodeRequest";
 import { ClientConfiguration } from "../config/ClientConfiguration";
 import { AuthenticationResult } from "../response/AuthenticationResult";
 import { EndSessionRequest } from "../request/EndSessionRequest";
+import { AuthorizationCodePayload } from "../response/AuthorizationCodePayload";
 /**
  * Oauth2.0 Authorization Code client
  */
@@ -25,13 +26,13 @@ export declare class AuthorizationCodeClient extends BaseClient {
      * authorization_code_grant
      * @param request
      */
-    acquireToken(request: AuthorizationCodeRequest, cachedNonce?: string, cachedState?: string): Promise<AuthenticationResult>;
+    acquireToken(request: AuthorizationCodeRequest, authCodePayload?: AuthorizationCodePayload): Promise<AuthenticationResult | null>;
     /**
      * Handles the hash fragment response from public client code request. Returns a code response used by
      * the client to exchange for a token in acquireToken.
      * @param hashFragment
      */
-    handleFragmentResponse(hashFragment: string, cachedState: string): string;
+    handleFragmentResponse(hashFragment: string, cachedState: string): AuthorizationCodePayload;
     /**
      * Use to log out the current user, and redirect the user to the postLogoutRedirectUri.
      * Default behaviour is to redirect the user to `window.location.href`.
@@ -54,4 +55,9 @@ export declare class AuthorizationCodeClient extends BaseClient {
      * @param request
      */
     private createAuthCodeUrlQueryString;
+    /**
+     * This API validates the `EndSessionRequest` and creates a URL
+     * @param request
+     */
+    private createLogoutUrlQueryString;
 }

package/dist/src/client/BaseClient.d.ts

@@ -1,4 +1,4 @@
-import { ClientConfiguration } from "../config/ClientConfiguration";
+import { ClientConfiguration, CommonClientConfiguration } from "../config/ClientConfiguration";
 import { INetworkModule } from "../network/INetworkModule";
 import { NetworkManager, NetworkResponse } from "../network/NetworkManager";
 import { ICrypto } from "../crypto/ICrypto";
@@ -13,13 +13,13 @@ import { RequestThumbprint } from "../network/RequestThumbprint";
  */
 export declare abstract class BaseClient {
     logger: Logger;
-    protected config: ClientConfiguration;
+    protected config: CommonClientConfiguration;
     protected cryptoUtils: ICrypto;
     protected cacheManager: CacheManager;
     protected networkClient: INetworkModule;
-    protected serverTelemetryManager: ServerTelemetryManager;
+    protected serverTelemetryManager: ServerTelemetryManager | null;
     protected networkManager: NetworkManager;
-    protected authority: Authority;
+    authority: Authority;
     protected constructor(configuration: ClientConfiguration);
     /**
      * Creates default headers for requests to token endpoint
@@ -37,4 +37,9 @@ export declare abstract class BaseClient {
      * @param thumbprint
      */
     protected executePostToTokenEndpoint(tokenEndpoint: string, queryString: string, headers: Record<string, string>, thumbprint: RequestThumbprint): Promise<NetworkResponse<ServerAuthorizationTokenResponse>>;
+    /**
+     * Updates the authority object of the client. Endpoint discovery must be completed.
+     * @param updatedAuthority
+     */
+    updateAuthority(updatedAuthority: Authority): void;
 }

package/dist/src/client/ClientCredentialClient.d.ts

@@ -8,9 +8,29 @@ import { ClientCredentialRequest } from "../request/ClientCredentialRequest";
 export declare class ClientCredentialClient extends BaseClient {
     private scopeSet;
     constructor(configuration: ClientConfiguration);
-    acquireToken(request: ClientCredentialRequest): Promise<AuthenticationResult>;
+    /**
+     * Public API to acquire a token with ClientCredential Flow for Confidential clients
+     * @param request
+     */
+    acquireToken(request: ClientCredentialRequest): Promise<AuthenticationResult | null>;
+    /**
+     * looks up cache if the tokens are cached already
+     */
     private getCachedAuthenticationResult;
+    /**
+     * Reads access token from the cache
+     * TODO: Move this call to cacheManager instead
+     */
     private readAccessTokenFromCache;
+    /**
+     * Makes a network call to request the token from the service
+     * @param request
+     * @param authority
+     */
     private executeTokenRequest;
+    /**
+     * generate the request to the server in the acceptable format
+     * @param request
+     */
     private createTokenRequestBody;
 }

package/dist/src/client/DeviceCodeClient.d.ts

@@ -12,7 +12,7 @@ export declare class DeviceCodeClient extends BaseClient {
      * polls token endpoint to exchange device code for tokens
      * @param request
      */
-    acquireToken(request: DeviceCodeRequest): Promise<AuthenticationResult>;
+    acquireToken(request: DeviceCodeRequest): Promise<AuthenticationResult | null>;
     /**
      * Creates device code request and executes http GET
      * @param request

package/dist/src/client/OnBehalfOfClient.d.ts

@@ -8,11 +8,40 @@ import { OnBehalfOfRequest } from "../request/OnBehalfOfRequest";
 export declare class OnBehalfOfClient extends BaseClient {
     private scopeSet;
     constructor(configuration: ClientConfiguration);
-    acquireToken(request: OnBehalfOfRequest): Promise<AuthenticationResult>;
+    /**
+     * Public API to acquire tokens with on behalf of flow
+     * @param request
+     */
+    acquireToken(request: OnBehalfOfRequest): Promise<AuthenticationResult | null>;
+    /**
+     * look up cache for tokens
+     * @param request
+     */
     private getCachedAuthenticationResult;
+    /**
+     * read access token from cache TODO: CacheManager API should be used here
+     * @param request
+     */
     private readAccessTokenFromCache;
+    /**
+     * read idtoken from cache TODO: CacheManager API should be used here instead
+     * @param request
+     */
     private readIdTokenFromCache;
+    /**
+     * read account from cache, TODO: CacheManager API should be used here instead
+     * @param account
+     */
     private readAccountFromCache;
+    /**
+     * Make a network call to the server requesting credentials
+     * @param request
+     * @param authority
+     */
     private executeTokenRequest;
+    /**
+     * generate a server request in accepable format
+     * @param request
+     */
     private createTokenRequestBody;
 }

package/dist/src/client/RefreshTokenClient.d.ts

@@ -8,12 +8,12 @@ import { SilentFlowRequest } from "../request/SilentFlowRequest";
  */
 export declare class RefreshTokenClient extends BaseClient {
     constructor(configuration: ClientConfiguration);
-    acquireToken(request: RefreshTokenRequest): Promise<AuthenticationResult>;
+    acquireToken(request: RefreshTokenRequest): Promise<AuthenticationResult | null>;
     /**
      * Gets cached refresh token and attaches to request, then calls acquireToken API
      * @param request
      */
-    acquireTokenByRefreshToken(request: SilentFlowRequest): Promise<AuthenticationResult>;
+    acquireTokenByRefreshToken(request: SilentFlowRequest): Promise<AuthenticationResult | null>;
     /**
      * makes a network call to acquire tokens by exchanging RefreshToken available in userCache; throws if refresh token is not cached
      * @param request

package/dist/src/client/SilentFlowClient.d.ts

@@ -9,7 +9,7 @@ export declare class SilentFlowClient extends BaseClient {
      * the given token and returns the renewed token
      * @param request
      */
-    acquireToken(request: SilentFlowRequest): Promise<AuthenticationResult>;
+    acquireToken(request: SilentFlowRequest): Promise<AuthenticationResult | null>;
     /**
      * Retrieves token from cache or throws an error if it must be refreshed.
      * @param request

package/dist/src/client/UsernamePasswordClient.d.ts

@@ -0,0 +1,28 @@
+import { BaseClient } from "./BaseClient";
+import { ClientConfiguration } from "../config/ClientConfiguration";
+import { UsernamePasswordRequest } from "../request/UsernamePasswordRequest";
+import { AuthenticationResult } from "../response/AuthenticationResult";
+/**
+ * Oauth2.0 Password grant client
+ * Note: We are only supporting public clients for password grant and for purely testing purposes
+ */
+export declare class UsernamePasswordClient extends BaseClient {
+    constructor(configuration: ClientConfiguration);
+    /**
+     * API to acquire a token by passing the username and password to the service in exchage of credentials
+     * password_grant
+     * @param request
+     */
+    acquireToken(request: UsernamePasswordRequest): Promise<AuthenticationResult | null>;
+    /**
+     * Executes POST request to token endpoint
+     * @param authority
+     * @param request
+     */
+    private executeTokenRequest;
+    /**
+     * Generates a map for all the params to be sent to the service
+     * @param request
+     */
+    private createTokenRequestBody;
+}

package/dist/src/config/ClientConfiguration.d.ts

@@ -29,9 +29,22 @@ export declare type ClientConfiguration = {
     cryptoInterface?: ICrypto;
     clientCredentials?: ClientCredentials;
     libraryInfo?: LibraryInfo;
-    serverTelemetryManager?: ServerTelemetryManager;
-    persistencePlugin?: ICachePlugin;
-    serializableCache?: ISerializableTokenCache;
+    serverTelemetryManager?: ServerTelemetryManager | null;
+    persistencePlugin?: ICachePlugin | null;
+    serializableCache?: ISerializableTokenCache | null;
+};
+export declare type CommonClientConfiguration = {
+    authOptions: Required<AuthOptions>;
+    systemOptions: Required<SystemOptions>;
+    loggerOptions: Required<LoggerOptions>;
+    storageInterface: CacheManager;
+    networkInterface: INetworkModule;
+    cryptoInterface: Required<ICrypto>;
+    libraryInfo: LibraryInfo;
+    serverTelemetryManager: ServerTelemetryManager | null;
+    clientCredentials: ClientCredentials;
+    persistencePlugin: ICachePlugin | null;
+    serializableCache: ISerializableTokenCache | null;
 };
 /**
  * Use this to configure the auth options in the ClientConfiguration object
@@ -45,7 +58,7 @@ export declare type ClientConfiguration = {
  */
 export declare type AuthOptions = {
     clientId: string;
-    authority?: Authority;
+    authority: Authority;
     knownAuthorities?: Array<string>;
     cloudDiscoveryMetadata?: string;
     clientCapabilities?: Array<string>;
@@ -90,7 +103,7 @@ export declare type ClientCredentials = {
         assertionType: string;
     };
 };
-export declare const DEFAULT_SYSTEM_OPTIONS: SystemOptions;
+export declare const DEFAULT_SYSTEM_OPTIONS: Required<SystemOptions>;
 /**
  * Function that sets the default options when not explicitly configured from app developer
  *
@@ -98,4 +111,4 @@ export declare const DEFAULT_SYSTEM_OPTIONS: SystemOptions;
  *
  * @returns Configuration
  */
-export declare function buildClientConfiguration({ authOptions: userAuthOptions, systemOptions: userSystemOptions, loggerOptions: userLoggerOption, storageInterface: storageImplementation, networkInterface: networkImplementation, cryptoInterface: cryptoImplementation, clientCredentials: clientCredentials, libraryInfo: libraryInfo, serverTelemetryManager: serverTelemetryManager, persistencePlugin: persistencePlugin, serializableCache: serializableCache }: ClientConfiguration): ClientConfiguration;
+export declare function buildClientConfiguration({ authOptions: userAuthOptions, systemOptions: userSystemOptions, loggerOptions: userLoggerOption, storageInterface: storageImplementation, networkInterface: networkImplementation, cryptoInterface: cryptoImplementation, clientCredentials: clientCredentials, libraryInfo: libraryInfo, serverTelemetryManager: serverTelemetryManager, persistencePlugin: persistencePlugin, serializableCache: serializableCache }: ClientConfiguration): CommonClientConfiguration;

package/dist/src/error/AuthError.d.ts

@@ -13,8 +13,8 @@ export declare const AuthErrorMessage: {
 export declare class AuthError extends Error {
     errorCode: string;
     errorMessage: string;
-    suberror: string;
-    constructor(errorCode: string, errorMessage?: string, suberror?: string);
+    subError: string;
+    constructor(errorCode?: string, errorMessage?: string, suberror?: string);
     /**
      * Creates an error that is thrown when something unexpected happens in the library.
      * @param errDesc

package/dist/src/error/ClientAuthError.d.ts

@@ -40,10 +40,18 @@ export declare const ClientAuthErrorMessage: {
         code: string;
         desc: string;
     };
+    stateNotFoundError: {
+        code: string;
+        desc: string;
+    };
     nonceMismatchError: {
         code: string;
         desc: string;
     };
+    nonceNotFoundError: {
+        code: string;
+        desc: string;
+    };
     noTokensFoundError: {
         code: string;
         desc: string;
@@ -56,6 +64,10 @@ export declare const ClientAuthErrorMessage: {
         code: string;
         desc: string;
     };
+    multipleMatchingAppMetadata: {
+        code: string;
+        desc: string;
+    };
     tokenRequestCannotBeMade: {
         code: string;
         desc: string;
@@ -132,6 +144,14 @@ export declare const ClientAuthErrorMessage: {
         code: string;
         desc: string;
     };
+    tokenClaimsRequired: {
+        code: string;
+        desc: string;
+    };
+    noAuthorizationCodeFromServer: {
+        code: string;
+        desc: string;
+    };
 };
 /**
  * Error thrown when there is an error in the client code running on the browser.
@@ -147,7 +167,7 @@ export declare class ClientAuthError extends AuthError {
      * Creates an error thrown if the client info is empty.
      * @param rawClientInfo
      */
-    static createClientInfoEmptyError(rawClientInfo: string): ClientAuthError;
+    static createClientInfoEmptyError(): ClientAuthError;
     /**
      * Creates an error thrown when the id token extraction errors out.
      * @param err
@@ -176,24 +196,36 @@ export declare class ClientAuthError extends AuthError {
      * Creates an error thrown when two states do not match.
      */
     static createStateMismatchError(): ClientAuthError;
+    /**
+     * Creates an error thrown when the state is not present
+     * @param missingState
+     */
+    static createStateNotFoundError(missingState: string): ClientAuthError;
     /**
      * Creates an error thrown when the nonce does not match.
      */
     static createNonceMismatchError(): ClientAuthError;
+    /**
+     * Creates an error thrown when the mnonce is not present
+     * @param missingNonce
+     */
+    static createNonceNotFoundError(missingNonce: string): ClientAuthError;
     /**
      * Creates an error thrown when the authorization code required for a token request is null or empty.
      */
     static createNoTokensFoundError(): ClientAuthError;
     /**
-     * Throws error when multiple tokens are in cache for the given scope.
-     * @param scope
+     * Throws error when multiple tokens are in cache.
      */
     static createMultipleMatchingTokensInCacheError(): ClientAuthError;
     /**
-     * Throws error when multiple tokens are in cache for the given scope.
-     * @param scope
+     * Throws error when multiple accounts are in cache for the given params
      */
     static createMultipleMatchingAccountsInCacheError(): ClientAuthError;
+    /**
+     * Throws error when multiple appMetada are in cache for the given clientId.
+     */
+    static createMultipleMatchingAppMetadataInCacheError(): ClientAuthError;
     /**
      * Throws error when no auth code or refresh token is given to ServerTokenRequestParameters.
      */
@@ -275,4 +307,12 @@ export declare class ClientAuthError extends AuthError {
      * Throws error if token cannot be retrieved from cache due to refresh being required.
      */
     static createRefreshRequiredError(): ClientAuthError;
+    /**
+     * Throws error if token claims are not populated for a signed jwt generation
+     */
+    static createTokenClaimsRequiredError(): ClientAuthError;
+    /**
+     * Throws error when the authorization code is missing from the server response
+     */
+    static createNoAuthCodeInServerResponseError(): ClientAuthError;
 }

package/dist/src/error/ClientConfigurationError.d.ts

@@ -75,6 +75,10 @@ export declare const ClientConfigurationErrorMessage: {
         code: string;
         desc: string;
     };
+    resourceRequestParametersRequired: {
+        code: string;
+        desc: string;
+    };
 };
 /**
  * Error thrown when there is an error in configuration of the MSAL.js library.
@@ -160,4 +164,8 @@ export declare class ClientConfigurationError extends ClientAuthError {
      * Throws error when provided authority is not a member of the trusted host list
      */
     static createUntrustedAuthorityError(): ClientConfigurationError;
+    /**
+     * Throws error when resourceRequestMethod or resourceRequestUri is missing
+     */
+    static createResourceRequestParametersRequiredError(): ClientConfigurationError;
 }

package/dist/src/error/InteractionRequiredAuthError.d.ts

@@ -8,6 +8,6 @@ export declare const InteractionRequiredAuthSubErrorMessage: string[];
  * Error thrown when user interaction is required at the auth server.
  */
 export declare class InteractionRequiredAuthError extends ServerError {
-    constructor(errorCode: string, errorMessage?: string, subError?: string);
-    static isInteractionRequiredError(errorCode: string, errorString: string, subError?: string): boolean;
+    constructor(errorCode?: string, errorMessage?: string, subError?: string);
+    static isInteractionRequiredError(errorCode?: string, errorString?: string, subError?: string): boolean;
 }

package/dist/src/error/ServerError.d.ts

@@ -3,6 +3,5 @@ import { AuthError } from "./AuthError";
  * Error thrown when there is an error with the server code, for example, unavailability.
  */
 export declare class ServerError extends AuthError {
-    subError: string;
-    constructor(errorCode: string, errorMessage?: string, subError?: string);
+    constructor(errorCode?: string, errorMessage?: string, subError?: string);
 }

package/dist/src/index.d.ts

@@ -4,6 +4,7 @@ export { RefreshTokenClient } from "./client/RefreshTokenClient";
 export { ClientCredentialClient } from "./client/ClientCredentialClient";
 export { OnBehalfOfClient } from "./client/OnBehalfOfClient";
 export { SilentFlowClient } from "./client/SilentFlowClient";
+export { UsernamePasswordClient } from "./client/UsernamePasswordClient";
 export { AuthOptions, SystemOptions, LoggerOptions, DEFAULT_SYSTEM_OPTIONS } from "./config/ClientConfiguration";
 export { ClientConfiguration } from "./config/ClientConfiguration";
 export { AccountInfo } from "./account/AccountInfo";
@@ -47,8 +48,11 @@ export { OnBehalfOfRequest } from "./request/OnBehalfOfRequest";
 export { SilentFlowRequest } from "./request/SilentFlowRequest";
 export { DeviceCodeRequest } from "./request/DeviceCodeRequest";
 export { EndSessionRequest } from "./request/EndSessionRequest";
+export { UsernamePasswordRequest } from "./request/UsernamePasswordRequest";
 export { AuthenticationResult } from "./response/AuthenticationResult";
+export { AuthorizationCodePayload } from "./response/AuthorizationCodePayload";
 export { ServerAuthorizationCodeResponse } from "./response/ServerAuthorizationCodeResponse";
+export { DeviceCodeResponse } from "./response/DeviceCodeResponse";
 export { ILoggerCallback, LogLevel, Logger } from "./logger/Logger";
 export { InteractionRequiredAuthError } from "./error/InteractionRequiredAuthError";
 export { AuthError, AuthErrorMessage } from "./error/AuthError";

package/dist/src/logger/Logger.d.ts

@@ -31,7 +31,13 @@ export declare class Logger {
     private level;
     private piiLoggingEnabled;
     private localCallback;
-    constructor(loggerOptions: LoggerOptions);
+    private packageName;
+    private packageVersion;
+    constructor(loggerOptions: LoggerOptions, packageName?: string, packageVersion?: string);
+    /**
+     * Create new Logger with existing configurations.
+     */
+    clone(packageName: string, packageVersion: string): Logger;
     /**
      * Log message with required options.
      */

package/dist/src/request/AuthorizationCodeRequest.d.ts

@@ -15,8 +15,8 @@ import { AuthenticationScheme } from "../utils/Constants";
  * - resourceRequestUri         - URI that token will be used for. Used for proof-of-possession flows.
  */
 export declare type AuthorizationCodeRequest = BaseAuthRequest & {
-    redirectUri: string;
+    authenticationScheme: AuthenticationScheme;
     code: string;
+    redirectUri: string;
     codeVerifier?: string;
-    authenticationScheme?: AuthenticationScheme;
 };

package/dist/src/request/AuthorizationUrlRequest.d.ts

@@ -31,18 +31,18 @@ import { AccountInfo } from "../account/AccountInfo";
  * - resourceRequestUri         - URI that token will be used for. Used for proof-of-possession flows.
  */
 export declare type AuthorizationUrlRequest = BaseAuthRequest & {
-    authenticationScheme?: AuthenticationScheme;
-    redirectUri?: string;
-    extraScopesToConsent?: Array<string>;
-    responseMode?: ResponseMode;
+    authenticationScheme: AuthenticationScheme;
+    redirectUri: string;
+    responseMode: ResponseMode;
+    account?: AccountInfo;
     codeChallenge?: string;
     codeChallengeMethod?: string;
-    state?: string;
-    prompt?: string;
-    account?: AccountInfo;
-    loginHint?: string;
     domainHint?: string;
-    sid?: string;
     extraQueryParameters?: StringDict;
+    extraScopesToConsent?: Array<string>;
+    loginHint?: string;
     nonce?: string;
+    prompt?: string;
+    sid?: string;
+    state?: string;
 };