@azure/msal-common 15.13.0 → 16.0.0-alpha.0

package/src/request/BaseAuthRequest.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { AuthenticationScheme, HttpMethod } from "../utils/Constants.js";
+import { AuthenticationScheme } from "../utils/Constants.js";
 import type { AzureCloudOptions } from "../config/ClientConfiguration.js";
 import { StringDict } from "../utils/MsalTypes.js";
 import { StoreInCache } from "./StoreInCache.js";
@@ -24,15 +24,12 @@ import { ShrOptions } from "../crypto/SignedHttpRequest.js";
  * - sshJwk                  - A stringified JSON Web Key representing a public key that can be signed by an SSH certificate.
  * - sshKid                  - Key ID that uniquely identifies the SSH public key mentioned above.
  * - azureCloudOptions       - Convenience string enums for users to provide public/sovereign cloud ids
- * - requestedClaimsHash     - SHA 256 hash string of the requested claims string, used as part of an access token cache key so tokens can be filtered by requested claims
  * - tokenQueryParameters    - String to string map of custom query parameters added to the /token call
  * - tokenBodyParameters     - String to string map of custom parameters added to the body of the /token call
  * - storeInCache            - Object containing boolean values indicating whether to store tokens in the cache or not (default is true)
  * - scenarioId              - Scenario id to track custom user prompts
  * - popKid                  - Key ID to identify the public key for PoP token request
  * - embeddedClientId        - Embedded client id. When specified, broker client id (brk_client_id) and redirect uri (brk_redirect_uri) params are set with values from the config, overriding the corresponding extra parameters, if present.
- * - httpMethod              - HTTP method to use for the /authorize request. Defaults to GET, but can be set to POST if the request requires body parameters
- * - authorizePostBodyParameters - String to string map of custom parameters added to the body of the /authorize call when httpMethod is set to POST
  */
 export type BaseAuthRequest = {
     authority: string;
@@ -48,7 +45,6 @@ export type BaseAuthRequest = {
     sshJwk?: string;
     sshKid?: string;
     azureCloudOptions?: AzureCloudOptions;
-    requestedClaimsHash?: string;
     maxAge?: number;
     tokenBodyParameters?: StringDict;
     tokenQueryParameters?: StringDict;
@@ -56,6 +52,4 @@ export type BaseAuthRequest = {
     scenarioId?: string;
     popKid?: string;
     embeddedClientId?: string;
-    httpMethod?: HttpMethod;
-    authorizePostBodyParameters?: StringDict;
 };

package/src/request/RequestParameterBuilder.ts

@@ -3,17 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import {
-    ResponseMode,
-    CLIENT_INFO,
-    AuthenticationScheme,
-    ClaimsRequestKeys,
-    PasswordGrantConstants,
-    OIDC_DEFAULT_SCOPES,
-    ThrottlingConstants,
-    HeaderNames,
-    OAuthResponseType,
-} from "../utils/Constants.js";
+import * as Constants from "../utils/Constants.js";
 import * as AADServerParamKeys from "../constants/AADServerParamKeys.js";
 import { ScopeSet } from "./ScopeSet.js";
 import {
@@ -59,7 +49,7 @@ export function instrumentBrokerParams(
  */
 export function addResponseType(
     parameters: Map<string, string>,
-    responseType: OAuthResponseType
+    responseType: Constants.OAuthResponseType
 ): void {
     parameters.set(AADServerParamKeys.RESPONSE_TYPE, responseType);
 }
@@ -70,11 +60,11 @@ export function addResponseType(
  */
 export function addResponseMode(
     parameters: Map<string, string>,
-    responseMode?: ResponseMode
+    responseMode?: Constants.ResponseMode
 ): void {
     parameters.set(
         AADServerParamKeys.RESPONSE_MODE,
-        responseMode ? responseMode : ResponseMode.QUERY
+        responseMode ? responseMode : Constants.ResponseMode.QUERY
     );
 }
 
@@ -94,7 +84,7 @@ export function addScopes(
     parameters: Map<string, string>,
     scopes: string[],
     addOidcScopes: boolean = true,
-    defaultScopes: Array<string> = OIDC_DEFAULT_SCOPES
+    defaultScopes: Array<string> = Constants.OIDC_DEFAULT_SCOPES
 ): void {
     // Always add openid to the scopes when adding OIDC scopes
     if (
@@ -185,7 +175,7 @@ export function addCcsUpn(
     parameters: Map<string, string>,
     loginHint: string
 ): void {
-    parameters.set(HeaderNames.CCS_HEADER, `UPN:${loginHint}`);
+    parameters.set(Constants.HeaderNames.CCS_HEADER, `UPN:${loginHint}`);
 }
 
 /**
@@ -197,7 +187,7 @@ export function addCcsOid(
     clientInfo: ClientInfo
 ): void {
     parameters.set(
-        HeaderNames.CCS_HEADER,
+        Constants.HeaderNames.CCS_HEADER,
         `Oid:${clientInfo.uid}@${clientInfo.utid}`
     );
 }
@@ -455,7 +445,7 @@ export function addGrantType(
  *
  */
 export function addClientInfo(parameters: Map<string, string>): void {
-    parameters.set(CLIENT_INFO, "1");
+    parameters.set(Constants.CLIENT_INFO, "1");
 }
 
 export function addInstanceAware(parameters: Map<string, string>): void {
@@ -499,16 +489,21 @@ export function addClientCapabilitiesToClaims(
     }
 
     if (clientCapabilities && clientCapabilities.length > 0) {
-        if (!mergedClaims.hasOwnProperty(ClaimsRequestKeys.ACCESS_TOKEN)) {
+        if (
+            !mergedClaims.hasOwnProperty(
+                Constants.ClaimsRequestKeys.ACCESS_TOKEN
+            )
+        ) {
             // Add access_token key to claims object
-            mergedClaims[ClaimsRequestKeys.ACCESS_TOKEN] = {};
+            mergedClaims[Constants.ClaimsRequestKeys.ACCESS_TOKEN] = {};
         }
 
         // Add xms_cc claim with provided clientCapabilities to access_token key
-        mergedClaims[ClaimsRequestKeys.ACCESS_TOKEN][ClaimsRequestKeys.XMS_CC] =
-            {
-                values: clientCapabilities,
-            };
+        mergedClaims[Constants.ClaimsRequestKeys.ACCESS_TOKEN][
+            Constants.ClaimsRequestKeys.XMS_CC
+        ] = {
+            values: clientCapabilities,
+        };
     }
 
     return JSON.stringify(mergedClaims);
@@ -522,7 +517,7 @@ export function addUsername(
     parameters: Map<string, string>,
     username: string
 ): void {
-    parameters.set(PasswordGrantConstants.username, username);
+    parameters.set(Constants.PasswordGrantConstants.username, username);
 }
 
 /**
@@ -533,7 +528,7 @@ export function addPassword(
     parameters: Map<string, string>,
     password: string
 ): void {
-    parameters.set(PasswordGrantConstants.password, password);
+    parameters.set(Constants.PasswordGrantConstants.password, password);
 }
 
 /**
@@ -545,7 +540,10 @@ export function addPopToken(
     cnfString: string
 ): void {
     if (cnfString) {
-        parameters.set(AADServerParamKeys.TOKEN_TYPE, AuthenticationScheme.POP);
+        parameters.set(
+            AADServerParamKeys.TOKEN_TYPE,
+            Constants.AuthenticationScheme.POP
+        );
         parameters.set(AADServerParamKeys.REQ_CNF, cnfString);
     }
 }
@@ -558,7 +556,10 @@ export function addSshJwk(
     sshJwkString: string
 ): void {
     if (sshJwkString) {
-        parameters.set(AADServerParamKeys.TOKEN_TYPE, AuthenticationScheme.SSH);
+        parameters.set(
+            AADServerParamKeys.TOKEN_TYPE,
+            Constants.AuthenticationScheme.SSH
+        );
         parameters.set(AADServerParamKeys.REQ_CNF, sshJwkString);
     }
 }
@@ -587,7 +588,7 @@ export function addServerTelemetry(
 export function addThrottling(parameters: Map<string, string>): void {
     parameters.set(
         AADServerParamKeys.X_MS_LIB_CAPABILITY,
-        ThrottlingConstants.X_MS_LIB_CAPABILITY_VALUE
+        Constants.X_MS_LIB_CAPABILITY_VALUE
     );
 }
 
@@ -632,19 +633,3 @@ export function addEARParameters(
     const jweCryptoB64Encoded = "eyJhbGciOiJkaXIiLCJlbmMiOiJBMjU2R0NNIn0";
     parameters.set(AADServerParamKeys.EAR_JWE_CRYPTO, jweCryptoB64Encoded);
 }
-
-/**
- * Adds authorize body parameters to the request parameters
- * @param parameters
- * @param bodyParameters
- */
-export function addPostBodyParameters(
-    parameters: Map<string, string>,
-    bodyParameters: StringDict
-): void {
-    Object.entries(bodyParameters).forEach(([key, value]) => {
-        if (value) {
-            parameters.set(key, value);
-        }
-    });
-}

package/src/request/ScopeSet.ts

@@ -13,9 +13,9 @@ import {
     createClientAuthError,
 } from "../error/ClientAuthError.js";
 import {
-    Constants,
     OIDC_SCOPES,
     OIDC_DEFAULT_SCOPES,
+    OFFLINE_ACCESS_SCOPE,
 } from "../utils/Constants.js";
 
 /**
@@ -54,7 +54,7 @@ export class ScopeSet {
      * @param scopesRequired
      */
     static fromString(inputScopeString: string): ScopeSet {
-        const scopeString = inputScopeString || Constants.EMPTY_STRING;
+        const scopeString = inputScopeString || "";
         const inputScopes: Array<string> = scopeString.split(" ");
         return new ScopeSet(inputScopes);
     }
@@ -75,7 +75,7 @@ export class ScopeSet {
         if (!scopeSet.containsOnlyOIDCScopes()) {
             scopeSet.removeOIDCScopes();
         } else {
-            scopeSet.removeScope(Constants.OFFLINE_ACCESS_SCOPE);
+            scopeSet.removeScope(OFFLINE_ACCESS_SCOPE);
         }
 
         return scopeSet;
@@ -234,7 +234,7 @@ export class ScopeSet {
             const scopeArr = this.asArray();
             return scopeArr.join(" ");
         }
-        return Constants.EMPTY_STRING;
+        return "";
     }
 
     /**

package/src/response/AuthenticationResult.ts

@@ -43,5 +43,5 @@ export type AuthenticationResult = {
     cloudGraphHostName?: string;
     msGraphHost?: string;
     code?: string;
-    fromNativeBroker?: boolean;
+    fromPlatformBroker?: boolean;
 };

package/src/response/ResponseHandler.ts

@@ -25,12 +25,7 @@ import {
 import { CacheRecord } from "../cache/entities/CacheRecord.js";
 import { CacheManager } from "../cache/CacheManager.js";
 import { ProtocolUtils, RequestStateObject } from "../utils/ProtocolUtils.js";
-import {
-    AuthenticationScheme,
-    Constants,
-    THE_FAMILY_ID,
-    HttpStatus,
-} from "../utils/Constants.js";
+import * as Constants from "../utils/Constants.js";
 import { PopTokenGenerator } from "../crypto/PopTokenGenerator.js";
 import { AppMetadataEntity } from "../cache/entities/AppMetadataEntity.js";
 import { ICachePlugin } from "../cache/interface/ICachePlugin.js";
@@ -38,8 +33,6 @@ import { TokenCacheContext } from "../cache/persistence/TokenCacheContext.js";
 import { ISerializableTokenCache } from "../cache/interface/ISerializableTokenCache.js";
 import { AuthorizationCodePayload } from "./AuthorizationCodePayload.js";
 import { BaseAuthRequest } from "../request/BaseAuthRequest.js";
-import { IPerformanceClient } from "../telemetry/performance/IPerformanceClient.js";
-import { PerformanceEvents } from "../telemetry/performance/PerformanceEvent.js";
 import { checkMaxAge, extractTokenClaims } from "../account/AuthToken.js";
 import {
     TokenClaims,
@@ -52,6 +45,8 @@ import {
 } from "../account/AccountInfo.js";
 import * as CacheHelpers from "../cache/utils/CacheHelpers.js";
 import * as TimeUtils from "../utils/TimeUtils.js";
+import * as AccountEntityUtils from "../cache/utils/AccountEntityUtils.js";
+import { IPerformanceClient } from "../telemetry/performance/IPerformanceClient.js";
 
 /**
  * Class that handles response parsing.
@@ -63,35 +58,37 @@ export class ResponseHandler {
     private cryptoObj: ICrypto;
     private logger: Logger;
     private homeAccountIdentifier: string;
+    private performanceClient: IPerformanceClient;
     private serializableCache: ISerializableTokenCache | null;
     private persistencePlugin: ICachePlugin | null;
-    private performanceClient?: IPerformanceClient;
 
     constructor(
         clientId: string,
         cacheStorage: CacheManager,
         cryptoObj: ICrypto,
         logger: Logger,
+        performanceClient: IPerformanceClient,
         serializableCache: ISerializableTokenCache | null,
-        persistencePlugin: ICachePlugin | null,
-        performanceClient?: IPerformanceClient
+        persistencePlugin: ICachePlugin | null
     ) {
         this.clientId = clientId;
         this.cacheStorage = cacheStorage;
         this.cryptoObj = cryptoObj;
         this.logger = logger;
+        this.performanceClient = performanceClient;
         this.serializableCache = serializableCache;
         this.persistencePlugin = persistencePlugin;
-        this.performanceClient = performanceClient;
     }
 
     /**
      * Function which validates server authorization token response.
      * @param serverResponse
+     * @param correlationId
      * @param refreshAccessToken
      */
     validateTokenResponse(
         serverResponse: ServerAuthorizationTokenResponse,
+        correlationId: string,
         refreshAccessToken?: boolean
     ): void {
         // Check for error
@@ -126,11 +123,13 @@ export class ResponseHandler {
             if (
                 refreshAccessToken &&
                 serverResponse.status &&
-                serverResponse.status >= HttpStatus.SERVER_ERROR_RANGE_START &&
-                serverResponse.status <= HttpStatus.SERVER_ERROR_RANGE_END
+                serverResponse.status >=
+                    Constants.HTTP_SERVER_ERROR_RANGE_START &&
+                serverResponse.status <= Constants.HTTP_SERVER_ERROR_RANGE_END
             ) {
                 this.logger.warning(
-                    `executeTokenRequest:validateTokenResponse - AAD is currently unavailable and the access token is unable to be refreshed.\n${serverError}`
+                    `executeTokenRequest:validateTokenResponse - AAD is currently unavailable and the access token is unable to be refreshed.\n${serverError}`,
+                    correlationId
                 );
 
                 // don't throw an exception, but alert the user via a log that the token was unable to be refreshed
@@ -139,11 +138,13 @@ export class ResponseHandler {
             } else if (
                 refreshAccessToken &&
                 serverResponse.status &&
-                serverResponse.status >= HttpStatus.CLIENT_ERROR_RANGE_START &&
-                serverResponse.status <= HttpStatus.CLIENT_ERROR_RANGE_END
+                serverResponse.status >=
+                    Constants.HTTP_CLIENT_ERROR_RANGE_START &&
+                serverResponse.status <= Constants.HTTP_CLIENT_ERROR_RANGE_END
             ) {
                 this.logger.warning(
-                    `executeTokenRequest:validateTokenResponse - AAD is currently available but is unable to refresh the access token.\n${serverError}`
+                    `executeTokenRequest:validateTokenResponse - AAD is currently available but is unable to refresh the access token.\n${serverError}`,
+                    correlationId
                 );
 
                 // don't throw an exception, but alert the user via a log that the token was unable to be refreshed
@@ -161,10 +162,10 @@ export class ResponseHandler {
                     serverResponse.error,
                     serverResponse.error_description,
                     serverResponse.suberror,
-                    serverResponse.timestamp || Constants.EMPTY_STRING,
-                    serverResponse.trace_id || Constants.EMPTY_STRING,
-                    serverResponse.correlation_id || Constants.EMPTY_STRING,
-                    serverResponse.claims || Constants.EMPTY_STRING,
+                    serverResponse.timestamp || "",
+                    serverResponse.trace_id || "",
+                    serverResponse.correlation_id || "",
+                    serverResponse.claims || "",
                     serverErrorNo
                 );
             }
@@ -189,16 +190,11 @@ export class ResponseHandler {
         forceCacheRefreshTokenResponse?: boolean,
         serverRequestId?: string
     ): Promise<AuthenticationResult> {
-        this.performanceClient?.addQueueMeasurement(
-            PerformanceEvents.HandleServerTokenResponse,
-            serverTokenResponse.correlation_id
-        );
-
         // create an idToken object (not entity)
         let idTokenClaims: TokenClaims | undefined;
         if (serverTokenResponse.id_token) {
             idTokenClaims = extractTokenClaims(
-                serverTokenResponse.id_token || Constants.EMPTY_STRING,
+                serverTokenResponse.id_token || "",
                 this.cryptoObj.base64Decode
             );
 
@@ -225,11 +221,12 @@ export class ResponseHandler {
         }
 
         // generate homeAccountId
-        this.homeAccountIdentifier = AccountEntity.generateHomeAccountId(
-            serverTokenResponse.client_info || Constants.EMPTY_STRING,
+        this.homeAccountIdentifier = AccountEntityUtils.generateHomeAccountId(
+            serverTokenResponse.client_info || "",
             authority.authorityType,
             this.logger,
             this.cryptoObj,
+            request.correlationId,
             idTokenClaims
         );
 
@@ -259,7 +256,8 @@ export class ResponseHandler {
         try {
             if (this.persistencePlugin && this.serializableCache) {
                 this.logger.verbose(
-                    "Persistence enabled, calling beforeCacheAccess"
+                    "Persistence enabled, calling beforeCacheAccess",
+                    request.correlationId
                 );
                 cacheContext = new TokenCacheContext(
                     this.serializableCache,
@@ -279,7 +277,7 @@ export class ResponseHandler {
                 cacheRecord.account
             ) {
                 const key = this.cacheStorage.generateAccountKey(
-                    cacheRecord.account.getAccountInfo()
+                    AccountEntityUtils.getAccountInfo(cacheRecord.account)
                 );
                 const account = this.cacheStorage.getAccount(
                     key,
@@ -287,7 +285,8 @@ export class ResponseHandler {
                 );
                 if (!account) {
                     this.logger.warning(
-                        "Account used to refresh tokens not in persistence, refreshed tokens will not be stored in the cache"
+                        "Account used to refresh tokens not in persistence, refreshed tokens will not be stored in the cache",
+                        request.correlationId
                     );
                     return await ResponseHandler.generateAuthenticationResult(
                         this.cryptoObj,
@@ -295,6 +294,7 @@ export class ResponseHandler {
                         cacheRecord,
                         false,
                         request,
+                        this.performanceClient,
                         idTokenClaims,
                         requestStateObj,
                         undefined,
@@ -314,7 +314,8 @@ export class ResponseHandler {
                 cacheContext
             ) {
                 this.logger.verbose(
-                    "Persistence enabled, calling afterCacheAccess"
+                    "Persistence enabled, calling afterCacheAccess",
+                    request.correlationId
                 );
                 await this.persistencePlugin.afterCacheAccess(cacheContext);
             }
@@ -326,6 +327,7 @@ export class ResponseHandler {
             cacheRecord,
             false,
             request,
+            this.performanceClient,
             idTokenClaims,
             requestStateObj,
             serverTokenResponse,
@@ -431,9 +433,7 @@ export class ResponseHandler {
                 refreshOnSeconds,
                 serverTokenResponse.token_type,
                 userAssertionHash,
-                serverTokenResponse.key_id,
-                request.claims,
-                request.requestedClaimsHash
+                serverTokenResponse.key_id
             );
         }
 
@@ -498,17 +498,18 @@ export class ResponseHandler {
         cacheRecord: CacheRecord,
         fromTokenCache: boolean,
         request: BaseAuthRequest,
+        performanceClient: IPerformanceClient,
         idTokenClaims?: TokenClaims,
         requestState?: RequestStateObject,
         serverTokenResponse?: ServerAuthorizationTokenResponse,
         requestId?: string
     ): Promise<AuthenticationResult> {
-        let accessToken: string = Constants.EMPTY_STRING;
+        let accessToken: string = "";
         let responseScopes: Array<string> = [];
         let expiresOn: Date | null = null;
         let extExpiresOn: Date | undefined;
         let refreshOn: Date | undefined;
-        let familyId: string = Constants.EMPTY_STRING;
+        let familyId: string = "";
 
         if (cacheRecord.accessToken) {
             /*
@@ -517,11 +518,11 @@ export class ResponseHandler {
              */
             if (
                 cacheRecord.accessToken.tokenType ===
-                    AuthenticationScheme.POP &&
+                    Constants.AuthenticationScheme.POP &&
                 !request.popKid
             ) {
                 const popTokenGenerator: PopTokenGenerator =
-                    new PopTokenGenerator(cryptoObj);
+                    new PopTokenGenerator(cryptoObj, performanceClient);
                 const { secret, keyId } = cacheRecord.accessToken;
 
                 if (!keyId) {
@@ -557,8 +558,8 @@ export class ResponseHandler {
 
         if (cacheRecord.appMetadata) {
             familyId =
-                cacheRecord.appMetadata.familyId === THE_FAMILY_ID
-                    ? THE_FAMILY_ID
+                cacheRecord.appMetadata.familyId === Constants.THE_FAMILY_ID
+                    ? Constants.THE_FAMILY_ID
                     : "";
         }
         const uid = idTokenClaims?.oid || idTokenClaims?.sub || "";
@@ -572,7 +573,7 @@ export class ResponseHandler {
 
         const accountInfo: AccountInfo | null = cacheRecord.account
             ? updateAccountTenantProfileData(
-                  cacheRecord.account.getAccountInfo(),
+                  AccountEntityUtils.getAccountInfo(cacheRecord.account),
                   undefined, // tenantProfile optional
                   idTokenClaims,
                   cacheRecord.idToken?.secret
@@ -593,20 +594,14 @@ export class ResponseHandler {
             extExpiresOn: extExpiresOn,
             refreshOn: refreshOn,
             correlationId: request.correlationId,
-            requestId: requestId || Constants.EMPTY_STRING,
+            requestId: requestId || "",
             familyId: familyId,
-            tokenType:
-                cacheRecord.accessToken?.tokenType || Constants.EMPTY_STRING,
-            state: requestState
-                ? requestState.userRequestState
-                : Constants.EMPTY_STRING,
-            cloudGraphHostName:
-                cacheRecord.account?.cloudGraphHostName ||
-                Constants.EMPTY_STRING,
-            msGraphHost:
-                cacheRecord.account?.msGraphHost || Constants.EMPTY_STRING,
+            tokenType: cacheRecord.accessToken?.tokenType || "",
+            state: requestState ? requestState.userRequestState : "",
+            cloudGraphHostName: cacheRecord.account?.cloudGraphHostName || "",
+            msGraphHost: cacheRecord.account?.msGraphHost || "",
             code: serverTokenResponse?.spa_code,
-            fromNativeBroker: false,
+            fromPlatformBroker: false,
         };
     }
 }
@@ -625,7 +620,7 @@ export function buildAccountToCache(
     nativeAccountId?: string,
     logger?: Logger
 ): AccountEntity {
-    logger?.verbose("setCachedAccount called");
+    logger?.verbose("setCachedAccount called", correlationId);
 
     // Check if base account is already cached
     const accountKeys = cacheStorage.getAccountKeys();
@@ -640,7 +635,7 @@ export function buildAccountToCache(
 
     const baseAccount =
         cachedAccount ||
-        AccountEntity.createAccount(
+        AccountEntityUtils.createAccountEntity(
             {
                 homeAccountId,
                 idTokenClaims,

package/src/telemetry/performance/IPerformanceClient.ts

@@ -4,25 +4,18 @@
  */
 
 import { PerformanceEvent } from "./PerformanceEvent.js";
-import { IPerformanceMeasurement } from "./IPerformanceMeasurement.js";
-import { AccountInfo } from "../../account/AccountInfo.js";
 
 export type PerformanceCallbackFunction = (events: PerformanceEvent[]) => void;
 
 export type InProgressPerformanceEvent = {
     end: (
         event?: Partial<PerformanceEvent>,
-        error?: unknown,
-        account?: AccountInfo
+        error?: unknown
     ) => PerformanceEvent | null;
     discard: () => void;
     add: (fields: { [key: string]: {} | undefined }) => void;
     increment: (fields: { [key: string]: number | undefined }) => void;
     event: PerformanceEvent;
-    /**
-     * @deprecated This attribute will be removed in the next major version
-     */
-    measurement: IPerformanceMeasurement;
 };
 
 export interface IPerformanceClient {
@@ -43,40 +36,5 @@ export interface IPerformanceClient {
     removePerformanceCallback(callbackId: string): boolean;
     addPerformanceCallback(callback: PerformanceCallbackFunction): string;
     emitEvents(events: PerformanceEvent[], correlationId: string): void;
-    /**
-     * @deprecated This method will be removed in the next major version
-     */
-    startPerformanceMeasurement(
-        measureName: string,
-        correlationId: string
-    ): IPerformanceMeasurement;
     generateId(): string;
-    calculateQueuedTime(preQueueTime: number, currentTime: number): number;
-    addQueueMeasurement(
-        eventName: string,
-        correlationId?: string,
-        queueTime?: number,
-        manuallyCompleted?: boolean
-    ): void;
-    setPreQueueTime(eventName: string, correlationId?: string): void;
 }
-
-/**
- * Queue measurement type
- */
-export type QueueMeasurement = {
-    /**
-     * Name of performance event
-     */
-    eventName: string;
-
-    /**
-     * Time spent in JS queue
-     */
-    queueTime: number;
-
-    /**
-     * Incomplete pre-queue events are instrumentation bugs that should be fixed.
-     */
-    manuallyCompleted?: boolean;
-};