@azure/msal-common 14.4.0 → 14.4.1-beta.1

package/dist/cache/utils/CacheHelpers.mjs

@@ -1,4 +1,4 @@
-/*! @azure/msal-common v14.4.0 2023-11-07 */
+/*! @azure/msal-common v14.4.1-beta.1 2023-11-14 */
 'use strict';
 import { extractTokenClaims } from '../../account/AuthToken.mjs';
 import { createClientAuthError } from '../../error/ClientAuthError.mjs';
@@ -6,236 +6,239 @@ import { Separators, CredentialType, AuthenticationScheme, SERVER_TELEM_CONSTANT
 import { TimeUtils } from '../../utils/TimeUtils.mjs';
 import { tokenClaimsCnfRequiredForSignedJwt } from '../../error/ClientAuthErrorCodes.mjs';
 
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-/**
- * Cache Key: <home_account_id>-<environment>-<credential_type>-<client_id or familyId>-<realm>-<scopes>-<claims hash>-<scheme>
- * IdToken Example: uid.utid-login.microsoftonline.com-idtoken-app_client_id-contoso.com
- * AccessToken Example: uid.utid-login.microsoftonline.com-accesstoken-app_client_id-contoso.com-scope1 scope2--pop
- * RefreshToken Example: uid.utid-login.microsoftonline.com-refreshtoken-1-contoso.com
- * @param credentialEntity
- * @returns
- */
-function generateCredentialKey(credentialEntity) {
-    const credentialKey = [
-        generateAccountId(credentialEntity),
-        generateCredentialId(credentialEntity),
-        generateTarget(credentialEntity),
-        generateClaimsHash(credentialEntity),
-        generateScheme(credentialEntity),
-    ];
-    return credentialKey.join(Separators.CACHE_KEY_SEPARATOR).toLowerCase();
-}
-/**
- * Create IdTokenEntity
- * @param homeAccountId
- * @param authenticationResult
- * @param clientId
- * @param authority
- */
-function createIdTokenEntity(homeAccountId, environment, idToken, clientId, tenantId) {
-    const idTokenEntity = {
-        credentialType: CredentialType.ID_TOKEN,
-        homeAccountId: homeAccountId,
-        environment: environment,
-        clientId: clientId,
-        secret: idToken,
-        realm: tenantId,
-    };
-    return idTokenEntity;
-}
-/**
- * Create AccessTokenEntity
- * @param homeAccountId
- * @param environment
- * @param accessToken
- * @param clientId
- * @param tenantId
- * @param scopes
- * @param expiresOn
- * @param extExpiresOn
- */
-function createAccessTokenEntity(homeAccountId, environment, accessToken, clientId, tenantId, scopes, expiresOn, extExpiresOn, base64Decode, refreshOn, tokenType, userAssertionHash, keyId, requestedClaims, requestedClaimsHash) {
-    const atEntity = {
-        homeAccountId: homeAccountId,
-        credentialType: CredentialType.ACCESS_TOKEN,
-        secret: accessToken,
-        cachedAt: TimeUtils.nowSeconds().toString(),
-        expiresOn: expiresOn.toString(),
-        extendedExpiresOn: extExpiresOn.toString(),
-        environment: environment,
-        clientId: clientId,
-        realm: tenantId,
-        target: scopes,
-        tokenType: tokenType || AuthenticationScheme.BEARER,
-    };
-    if (userAssertionHash) {
-        atEntity.userAssertionHash = userAssertionHash;
-    }
-    if (refreshOn) {
-        atEntity.refreshOn = refreshOn.toString();
-    }
-    if (requestedClaims) {
-        atEntity.requestedClaims = requestedClaims;
-        atEntity.requestedClaimsHash = requestedClaimsHash;
-    }
-    /*
-     * Create Access Token With Auth Scheme instead of regular access token
-     * Cast to lower to handle "bearer" from ADFS
-     */
-    if (atEntity.tokenType?.toLowerCase() !==
-        AuthenticationScheme.BEARER.toLowerCase()) {
-        atEntity.credentialType = CredentialType.ACCESS_TOKEN_WITH_AUTH_SCHEME;
-        switch (atEntity.tokenType) {
-            case AuthenticationScheme.POP:
-                // Make sure keyId is present and add it to credential
-                const tokenClaims = extractTokenClaims(accessToken, base64Decode);
-                if (!tokenClaims?.cnf?.kid) {
-                    throw createClientAuthError(tokenClaimsCnfRequiredForSignedJwt);
-                }
-                atEntity.keyId = tokenClaims.cnf.kid;
-                break;
-            case AuthenticationScheme.SSH:
-                atEntity.keyId = keyId;
-        }
-    }
-    return atEntity;
-}
-/**
- * Create RefreshTokenEntity
- * @param homeAccountId
- * @param authenticationResult
- * @param clientId
- * @param authority
- */
-function createRefreshTokenEntity(homeAccountId, environment, refreshToken, clientId, familyId, userAssertionHash) {
-    const rtEntity = {
-        credentialType: CredentialType.REFRESH_TOKEN,
-        homeAccountId: homeAccountId,
-        environment: environment,
-        clientId: clientId,
-        secret: refreshToken,
-    };
-    if (userAssertionHash) {
-        rtEntity.userAssertionHash = userAssertionHash;
-    }
-    if (familyId) {
-        rtEntity.familyId = familyId;
-    }
-    return rtEntity;
-}
-function isCredentialEntity(entity) {
-    return (entity.hasOwnProperty("homeAccountId") &&
-        entity.hasOwnProperty("environment") &&
-        entity.hasOwnProperty("credentialType") &&
-        entity.hasOwnProperty("clientId") &&
-        entity.hasOwnProperty("secret"));
-}
-/**
- * Validates an entity: checks for all expected params
- * @param entity
- */
-function isAccessTokenEntity(entity) {
-    if (!entity) {
-        return false;
-    }
-    return (isCredentialEntity(entity) &&
-        entity.hasOwnProperty("realm") &&
-        entity.hasOwnProperty("target") &&
-        (entity["credentialType"] === CredentialType.ACCESS_TOKEN ||
-            entity["credentialType"] ===
-                CredentialType.ACCESS_TOKEN_WITH_AUTH_SCHEME));
-}
-/**
- * Validates an entity: checks for all expected params
- * @param entity
- */
-function isIdTokenEntity(entity) {
-    if (!entity) {
-        return false;
-    }
-    return (isCredentialEntity(entity) &&
-        entity.hasOwnProperty("realm") &&
-        entity["credentialType"] === CredentialType.ID_TOKEN);
-}
-/**
- * Validates an entity: checks for all expected params
- * @param entity
- */
-function isRefreshTokenEntity(entity) {
-    if (!entity) {
-        return false;
-    }
-    return (isCredentialEntity(entity) &&
-        entity["credentialType"] === CredentialType.REFRESH_TOKEN);
-}
-/**
- * Generate Account Id key component as per the schema: <home_account_id>-<environment>
- */
-function generateAccountId(credentialEntity) {
-    const accountId = [
-        credentialEntity.homeAccountId,
-        credentialEntity.environment,
-    ];
-    return accountId.join(Separators.CACHE_KEY_SEPARATOR).toLowerCase();
-}
-/**
- * Generate Credential Id key component as per the schema: <credential_type>-<client_id>-<realm>
- */
-function generateCredentialId(credentialEntity) {
-    const clientOrFamilyId = credentialEntity.credentialType === CredentialType.REFRESH_TOKEN
-        ? credentialEntity.familyId || credentialEntity.clientId
-        : credentialEntity.clientId;
-    const credentialId = [
-        credentialEntity.credentialType,
-        clientOrFamilyId,
-        credentialEntity.realm || "",
-    ];
-    return credentialId.join(Separators.CACHE_KEY_SEPARATOR).toLowerCase();
-}
-/**
- * Generate target key component as per schema: <target>
- */
-function generateTarget(credentialEntity) {
-    return (credentialEntity.target || "").toLowerCase();
-}
-/**
- * Generate requested claims key component as per schema: <requestedClaims>
- */
-function generateClaimsHash(credentialEntity) {
-    return (credentialEntity.requestedClaimsHash || "").toLowerCase();
-}
-/**
- * Generate scheme key componenet as per schema: <scheme>
- */
-function generateScheme(credentialEntity) {
-    /*
-     * PoP Tokens and SSH certs include scheme in cache key
-     * Cast to lowercase to handle "bearer" from ADFS
-     */
-    return credentialEntity.tokenType &&
-        credentialEntity.tokenType.toLowerCase() !==
-            AuthenticationScheme.BEARER.toLowerCase()
-        ? credentialEntity.tokenType.toLowerCase()
-        : "";
-}
-/**
- * validates if a given cache entry is "Telemetry", parses <key,value>
- * @param key
- * @param entity
- */
-function isServerTelemetryEntity(key, entity) {
-    const validateKey = key.indexOf(SERVER_TELEM_CONSTANTS.CACHE_KEY) === 0;
-    let validateEntity = true;
-    if (entity) {
-        validateEntity =
-            entity.hasOwnProperty("failedRequests") &&
-                entity.hasOwnProperty("errors") &&
-                entity.hasOwnProperty("cacheHits");
-    }
-    return validateKey && validateEntity;
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+/**
+ * Cache Key: <home_account_id>-<environment>-<credential_type>-<client_id or familyId>-<realm>-<scopes>-<claims hash>-<scheme>
+ * IdToken Example: uid.utid-login.microsoftonline.com-idtoken-app_client_id-contoso.com
+ * AccessToken Example: uid.utid-login.microsoftonline.com-accesstoken-app_client_id-contoso.com-scope1 scope2--pop
+ * RefreshToken Example: uid.utid-login.microsoftonline.com-refreshtoken-1-contoso.com
+ * @param credentialEntity
+ * @returns
+ */
+function generateCredentialKey(credentialEntity) {
+    const credentialKey = [
+        generateAccountId(credentialEntity),
+        generateCredentialId(credentialEntity),
+        generateTarget(credentialEntity),
+        generateClaimsHash(credentialEntity),
+        generateScheme(credentialEntity),
+    ];
+    return credentialKey.join(Separators.CACHE_KEY_SEPARATOR).toLowerCase();
+}
+/**
+ * Create IdTokenEntity
+ * @param homeAccountId
+ * @param authenticationResult
+ * @param clientId
+ * @param authority
+ */
+function createIdTokenEntity(homeAccountId, environment, idToken, clientId, tenantId) {
+    const idTokenEntity = {
+        credentialType: CredentialType.ID_TOKEN,
+        homeAccountId: homeAccountId,
+        environment: environment,
+        clientId: clientId,
+        secret: idToken,
+        realm: tenantId,
+    };
+    return idTokenEntity;
+}
+/**
+ * Create AccessTokenEntity
+ * @param homeAccountId
+ * @param environment
+ * @param accessToken
+ * @param clientId
+ * @param tenantId
+ * @param scopes
+ * @param expiresOn
+ * @param extExpiresOn
+ */
+function createAccessTokenEntity(homeAccountId, environment, accessToken, clientId, tenantId, scopes, expiresOn, extExpiresOn, base64Decode, refreshOn, tokenType, userAssertionHash, keyId, requestedClaims, requestedClaimsHash) {
+    const atEntity = {
+        homeAccountId: homeAccountId,
+        credentialType: CredentialType.ACCESS_TOKEN,
+        secret: accessToken,
+        cachedAt: TimeUtils.nowSeconds().toString(),
+        expiresOn: expiresOn.toString(),
+        extendedExpiresOn: extExpiresOn.toString(),
+        environment: environment,
+        clientId: clientId,
+        realm: tenantId,
+        target: scopes,
+        tokenType: tokenType || AuthenticationScheme.BEARER,
+    };
+    if (userAssertionHash) {
+        atEntity.userAssertionHash = userAssertionHash;
+    }
+    if (refreshOn) {
+        atEntity.refreshOn = refreshOn.toString();
+    }
+    if (requestedClaims) {
+        atEntity.requestedClaims = requestedClaims;
+        atEntity.requestedClaimsHash = requestedClaimsHash;
+    }
+    /*
+     * Create Access Token With Auth Scheme instead of regular access token
+     * Cast to lower to handle "bearer" from ADFS
+     */
+    if (atEntity.tokenType?.toLowerCase() !==
+        AuthenticationScheme.BEARER.toLowerCase()) {
+        atEntity.credentialType = CredentialType.ACCESS_TOKEN_WITH_AUTH_SCHEME;
+        switch (atEntity.tokenType) {
+            case AuthenticationScheme.POP:
+                // Make sure keyId is present and add it to credential
+                const tokenClaims = extractTokenClaims(accessToken, base64Decode);
+                if (!tokenClaims?.cnf?.kid) {
+                    throw createClientAuthError(tokenClaimsCnfRequiredForSignedJwt);
+                }
+                atEntity.keyId = tokenClaims.cnf.kid;
+                break;
+            case AuthenticationScheme.SSH:
+                atEntity.keyId = keyId;
+        }
+    }
+    return atEntity;
+}
+/**
+ * Create RefreshTokenEntity
+ * @param homeAccountId
+ * @param authenticationResult
+ * @param clientId
+ * @param authority
+ */
+function createRefreshTokenEntity(homeAccountId, environment, refreshToken, clientId, familyId, userAssertionHash, expiresOn) {
+    const rtEntity = {
+        credentialType: CredentialType.REFRESH_TOKEN,
+        homeAccountId: homeAccountId,
+        environment: environment,
+        clientId: clientId,
+        secret: refreshToken,
+    };
+    if (userAssertionHash) {
+        rtEntity.userAssertionHash = userAssertionHash;
+    }
+    if (familyId) {
+        rtEntity.familyId = familyId;
+    }
+    if (expiresOn) {
+        rtEntity.expiresOn = expiresOn;
+    }
+    return rtEntity;
+}
+function isCredentialEntity(entity) {
+    return (entity.hasOwnProperty("homeAccountId") &&
+        entity.hasOwnProperty("environment") &&
+        entity.hasOwnProperty("credentialType") &&
+        entity.hasOwnProperty("clientId") &&
+        entity.hasOwnProperty("secret"));
+}
+/**
+ * Validates an entity: checks for all expected params
+ * @param entity
+ */
+function isAccessTokenEntity(entity) {
+    if (!entity) {
+        return false;
+    }
+    return (isCredentialEntity(entity) &&
+        entity.hasOwnProperty("realm") &&
+        entity.hasOwnProperty("target") &&
+        (entity["credentialType"] === CredentialType.ACCESS_TOKEN ||
+            entity["credentialType"] ===
+                CredentialType.ACCESS_TOKEN_WITH_AUTH_SCHEME));
+}
+/**
+ * Validates an entity: checks for all expected params
+ * @param entity
+ */
+function isIdTokenEntity(entity) {
+    if (!entity) {
+        return false;
+    }
+    return (isCredentialEntity(entity) &&
+        entity.hasOwnProperty("realm") &&
+        entity["credentialType"] === CredentialType.ID_TOKEN);
+}
+/**
+ * Validates an entity: checks for all expected params
+ * @param entity
+ */
+function isRefreshTokenEntity(entity) {
+    if (!entity) {
+        return false;
+    }
+    return (isCredentialEntity(entity) &&
+        entity["credentialType"] === CredentialType.REFRESH_TOKEN);
+}
+/**
+ * Generate Account Id key component as per the schema: <home_account_id>-<environment>
+ */
+function generateAccountId(credentialEntity) {
+    const accountId = [
+        credentialEntity.homeAccountId,
+        credentialEntity.environment,
+    ];
+    return accountId.join(Separators.CACHE_KEY_SEPARATOR).toLowerCase();
+}
+/**
+ * Generate Credential Id key component as per the schema: <credential_type>-<client_id>-<realm>
+ */
+function generateCredentialId(credentialEntity) {
+    const clientOrFamilyId = credentialEntity.credentialType === CredentialType.REFRESH_TOKEN
+        ? credentialEntity.familyId || credentialEntity.clientId
+        : credentialEntity.clientId;
+    const credentialId = [
+        credentialEntity.credentialType,
+        clientOrFamilyId,
+        credentialEntity.realm || "",
+    ];
+    return credentialId.join(Separators.CACHE_KEY_SEPARATOR).toLowerCase();
+}
+/**
+ * Generate target key component as per schema: <target>
+ */
+function generateTarget(credentialEntity) {
+    return (credentialEntity.target || "").toLowerCase();
+}
+/**
+ * Generate requested claims key component as per schema: <requestedClaims>
+ */
+function generateClaimsHash(credentialEntity) {
+    return (credentialEntity.requestedClaimsHash || "").toLowerCase();
+}
+/**
+ * Generate scheme key componenet as per schema: <scheme>
+ */
+function generateScheme(credentialEntity) {
+    /*
+     * PoP Tokens and SSH certs include scheme in cache key
+     * Cast to lowercase to handle "bearer" from ADFS
+     */
+    return credentialEntity.tokenType &&
+        credentialEntity.tokenType.toLowerCase() !==
+            AuthenticationScheme.BEARER.toLowerCase()
+        ? credentialEntity.tokenType.toLowerCase()
+        : "";
+}
+/**
+ * validates if a given cache entry is "Telemetry", parses <key,value>
+ * @param key
+ * @param entity
+ */
+function isServerTelemetryEntity(key, entity) {
+    const validateKey = key.indexOf(SERVER_TELEM_CONSTANTS.CACHE_KEY) === 0;
+    let validateEntity = true;
+    if (entity) {
+        validateEntity =
+            entity.hasOwnProperty("failedRequests") &&
+                entity.hasOwnProperty("errors") &&
+                entity.hasOwnProperty("cacheHits");
+    }
+    return validateKey && validateEntity;
 }
 
 export { createAccessTokenEntity, createIdTokenEntity, createRefreshTokenEntity, generateCredentialKey, isAccessTokenEntity, isCredentialEntity, isIdTokenEntity, isRefreshTokenEntity, isServerTelemetryEntity };

package/dist/cache/utils/CacheHelpers.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"CacheHelpers.mjs","sources":["../../../src/cache/utils/CacheHelpers.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;AAWA;AAOA;AACA;AACA;;;;;AAUG;AACH;AAcA;;;;;;AAMG,QAAA,cAAA,CAAA,gBAAA,CAAA;AACH,QAAgB,kBAAA,CAAA,gBAAmB,CAC/B;AAkBJ,QAAA,cAAA,CAAA,gBAAA,CAAA;;;;;;;;;;AAUG;AACH,SAAA,mBAAuC,CAAA,aACtB,EAAA,WAAA,SACb,EAAA,QAAA,EAAa,UACF;AAwEf,IAAA,MAAA,aAAA,GAAA;;;;;;AAMG,QAAA,KAAA,EAAA,QAAA;AACH,KAAA,CAAA;AA2BA,IAAA,OAAA,aAAgB;AAUhB,CAAA;;;AAGG;AACH;AAeA;;;AAGG;AACH;AAYA;;;AAGG,IAAA,MAAA,QAAA,GAAA;AACH,QAAA,aAAA,EAAA;AAoEA,QAAA,cAAA,EAAA,cAAA,CAAA,YAAA;;;;AAIG,QAAA,iBAAA,EAAA,YAAA,CAAA,QAAA,EAAA;AACH,QAAA,WAAA,EAAA,WAAuC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"CacheHelpers.mjs","sources":["../../../src/cache/utils/CacheHelpers.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;AAWA;AAOA;AACA;AACA;;;;;AAUG;AACH;AAcA;;;;;;AAMG,QAAA,cAAA,CAAA,gBAAA,CAAA;AACH,QAAgB,kBAAA,CAAA,gBAAmB,CAC/B;AAkBJ,QAAA,cAAA,CAAA,gBAAA,CAAA;;;;;;;;;;AAUG;AACH,SAAA,mBAAuC,CAAA,aACtB,EAAA,WAAA,SACb,EAAA,QAAA,EAAa,UACF;AAwEf,IAAA,MAAA,aAAA,GAAA;;;;;;AAMG,QAAA,KAAA,EAAA,QAAA;AACH,KAAA,CAAA;AAgCA,IAAA,OAAA,aAAgB;AAUhB,CAAA;;;AAGG;AACH;AAeA;;;AAGG;AACH;AAYA;;;AAGG,IAAA,MAAA,QAAA,GAAA;AACH,QAAA,aAAA,EAAA;AAoEA,QAAA,cAAA,EAAA,cAAA,CAAA,YAAA;;;;AAIG,QAAA,iBAAA,EAAA,YAAA,CAAA,QAAA,EAAA;AACH,QAAA,WAAA,EAAA,WAAuC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cache/utils/CacheTypes.d.ts

@@ -1,68 +1,68 @@
-import { AccountEntity } from "../entities/AccountEntity";
-import { IdTokenEntity } from "../entities/IdTokenEntity";
-import { AccessTokenEntity } from "../entities/AccessTokenEntity";
-import { RefreshTokenEntity } from "../entities/RefreshTokenEntity";
-import { AppMetadataEntity } from "../entities/AppMetadataEntity";
-import { ServerTelemetryEntity } from "../entities/ServerTelemetryEntity";
-import { ThrottlingEntity } from "../entities/ThrottlingEntity";
-import { AuthorityMetadataEntity } from "../entities/AuthorityMetadataEntity";
-import { AuthenticationScheme } from "../../utils/Constants";
-import { ScopeSet } from "../../request/ScopeSet";
-import { AccountInfo } from "../../account/AccountInfo";
-/** @internal */
-export type AccountCache = Record<string, AccountEntity>;
-/** @internal */
-export type IdTokenCache = Record<string, IdTokenEntity>;
-/** @internal */
-export type AccessTokenCache = Record<string, AccessTokenEntity>;
-/** @internal */
-export type RefreshTokenCache = Record<string, RefreshTokenEntity>;
-/** @internal */
-export type AppMetadataCache = Record<string, AppMetadataEntity>;
-/**
- * Object type of all accepted cache types
- * @internal
- */
-export type ValidCacheType = AccountEntity | IdTokenEntity | AccessTokenEntity | RefreshTokenEntity | AppMetadataEntity | AuthorityMetadataEntity | ServerTelemetryEntity | ThrottlingEntity | string;
-/**
- * Object type of all credential types
- * @internal
- */
-export type ValidCredentialType = IdTokenEntity | AccessTokenEntity | RefreshTokenEntity;
-/**
- * Account:	<home_account_id>-<environment>-<realm*>
- */
-export type AccountFilter = Omit<Partial<AccountInfo>, "idToken" | "idTokenClaims"> & {
-    realm?: string;
-    loginHint?: string;
-    sid?: string;
-};
-/**
- * Credential: <home_account_id*>-<environment>-<credential_type>-<client_id>-<realm*>-<target*>-<scheme*>
- */
-export type CredentialFilter = {
-    homeAccountId?: string;
-    environment?: string;
-    credentialType?: string;
-    clientId?: string;
-    familyId?: string;
-    realm?: string;
-    target?: ScopeSet;
-    userAssertionHash?: string;
-    tokenType?: AuthenticationScheme;
-    keyId?: string;
-    requestedClaimsHash?: string;
-};
-/**
- * AppMetadata: appmetadata-<environment>-<client_id>
- */
-export type AppMetadataFilter = {
-    environment?: string;
-    clientId?: string;
-};
-export type TokenKeys = {
-    idToken: string[];
-    accessToken: string[];
-    refreshToken: string[];
-};
+import { AccountEntity } from "../entities/AccountEntity";
+import { IdTokenEntity } from "../entities/IdTokenEntity";
+import { AccessTokenEntity } from "../entities/AccessTokenEntity";
+import { RefreshTokenEntity } from "../entities/RefreshTokenEntity";
+import { AppMetadataEntity } from "../entities/AppMetadataEntity";
+import { ServerTelemetryEntity } from "../entities/ServerTelemetryEntity";
+import { ThrottlingEntity } from "../entities/ThrottlingEntity";
+import { AuthorityMetadataEntity } from "../entities/AuthorityMetadataEntity";
+import { AuthenticationScheme } from "../../utils/Constants";
+import { ScopeSet } from "../../request/ScopeSet";
+import { AccountInfo } from "../../account/AccountInfo";
+/** @internal */
+export type AccountCache = Record<string, AccountEntity>;
+/** @internal */
+export type IdTokenCache = Record<string, IdTokenEntity>;
+/** @internal */
+export type AccessTokenCache = Record<string, AccessTokenEntity>;
+/** @internal */
+export type RefreshTokenCache = Record<string, RefreshTokenEntity>;
+/** @internal */
+export type AppMetadataCache = Record<string, AppMetadataEntity>;
+/**
+ * Object type of all accepted cache types
+ * @internal
+ */
+export type ValidCacheType = AccountEntity | IdTokenEntity | AccessTokenEntity | RefreshTokenEntity | AppMetadataEntity | AuthorityMetadataEntity | ServerTelemetryEntity | ThrottlingEntity | string;
+/**
+ * Object type of all credential types
+ * @internal
+ */
+export type ValidCredentialType = IdTokenEntity | AccessTokenEntity | RefreshTokenEntity;
+/**
+ * Account:	<home_account_id>-<environment>-<realm*>
+ */
+export type AccountFilter = Omit<Partial<AccountInfo>, "idToken" | "idTokenClaims"> & {
+    realm?: string;
+    loginHint?: string;
+    sid?: string;
+};
+/**
+ * Credential: <home_account_id*>-<environment>-<credential_type>-<client_id>-<realm*>-<target*>-<scheme*>
+ */
+export type CredentialFilter = {
+    homeAccountId?: string;
+    environment?: string;
+    credentialType?: string;
+    clientId?: string;
+    familyId?: string;
+    realm?: string;
+    target?: ScopeSet;
+    userAssertionHash?: string;
+    tokenType?: AuthenticationScheme;
+    keyId?: string;
+    requestedClaimsHash?: string;
+};
+/**
+ * AppMetadata: appmetadata-<environment>-<client_id>
+ */
+export type AppMetadataFilter = {
+    environment?: string;
+    clientId?: string;
+};
+export type TokenKeys = {
+    idToken: string[];
+    accessToken: string[];
+    refreshToken: string[];
+};
 //# sourceMappingURL=CacheTypes.d.ts.map