plugin-data-source-mssql 2.0.10 → 2.0.12

package/dist/tedious/node_modules/@azure/msal-browser/node_modules/@azure/msal-common/src/client/SilentFlowClient.ts

@@ -0,0 +1,272 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import {
+    buildClientConfiguration,
+    ClientConfiguration,
+    CommonClientConfiguration,
+} from "../config/ClientConfiguration.js";
+import { CommonSilentFlowRequest } from "../request/CommonSilentFlowRequest.js";
+import { AuthenticationResult } from "../response/AuthenticationResult.js";
+import * as TimeUtils from "../utils/TimeUtils.js";
+import {
+    ClientAuthErrorCodes,
+    createClientAuthError,
+} from "../error/ClientAuthError.js";
+import { ResponseHandler } from "../response/ResponseHandler.js";
+import { CacheRecord } from "../cache/entities/CacheRecord.js";
+import { CacheOutcome } from "../utils/Constants.js";
+import { IPerformanceClient } from "../telemetry/performance/IPerformanceClient.js";
+import { StringUtils } from "../utils/StringUtils.js";
+import { checkMaxAge, extractTokenClaims } from "../account/AuthToken.js";
+import { TokenClaims } from "../account/TokenClaims.js";
+import * as PerformanceEvents from "../telemetry/performance/PerformanceEvents.js";
+import { invokeAsync } from "../utils/FunctionWrappers.js";
+import {
+    Authority,
+    getTenantFromAuthorityString,
+} from "../authority/Authority.js";
+import { Logger } from "../logger/Logger.js";
+import { ICrypto } from "../crypto/ICrypto.js";
+import { CacheManager } from "../cache/CacheManager.js";
+import { INetworkModule } from "../network/INetworkModule.js";
+import { ServerTelemetryManager } from "../telemetry/server/ServerTelemetryManager.js";
+import { version, name } from "../packageMetadata.js";
+
+/** @internal */
+export class SilentFlowClient {
+    // Logger object
+    public logger: Logger;
+
+    // Application config
+    protected config: CommonClientConfiguration;
+
+    // Crypto Interface
+    protected cryptoUtils: ICrypto;
+
+    // Storage Interface
+    protected cacheManager: CacheManager;
+
+    // Network Interface
+    protected networkClient: INetworkModule;
+
+    // Server Telemetry Manager
+    protected serverTelemetryManager: ServerTelemetryManager | null;
+
+    // Default authority object
+    public authority: Authority;
+
+    // Performance telemetry client
+    protected performanceClient: IPerformanceClient;
+
+    constructor(
+        configuration: ClientConfiguration,
+        performanceClient: IPerformanceClient
+    ) {
+        // Set the configuration
+        this.config = buildClientConfiguration(configuration);
+
+        // Initialize the logger
+        this.logger = new Logger(this.config.loggerOptions, name, version);
+
+        // Initialize crypto
+        this.cryptoUtils = this.config.cryptoInterface;
+
+        // Initialize storage interface
+        this.cacheManager = this.config.storageInterface;
+
+        // Set the network interface
+        this.networkClient = this.config.networkInterface;
+
+        // Set TelemetryManager
+        this.serverTelemetryManager = this.config.serverTelemetryManager;
+
+        // set Authority
+        this.authority = this.config.authOptions.authority;
+
+        // set performance telemetry client
+        this.performanceClient = performanceClient;
+    }
+
+    /**
+     * Retrieves token from cache or throws an error if it must be refreshed.
+     * @param request
+     */
+    async acquireCachedToken(
+        request: CommonSilentFlowRequest
+    ): Promise<[AuthenticationResult, CacheOutcome]> {
+        let lastCacheOutcome: CacheOutcome = CacheOutcome.NOT_APPLICABLE;
+
+        if (request.forceRefresh || !StringUtils.isEmptyObj(request.claims)) {
+            // Must refresh due to present force_refresh flag.
+            this.setCacheOutcome(
+                CacheOutcome.FORCE_REFRESH_OR_CLAIMS,
+                request.correlationId
+            );
+            throw createClientAuthError(
+                ClientAuthErrorCodes.tokenRefreshRequired
+            );
+        }
+
+        // We currently do not support silent flow for account === null use cases; This will be revisited for confidential flow usecases
+        if (!request.account) {
+            throw createClientAuthError(
+                ClientAuthErrorCodes.noAccountInSilentRequest
+            );
+        }
+
+        const requestTenantId =
+            request.account.tenantId ||
+            getTenantFromAuthorityString(request.authority);
+        const tokenKeys = this.cacheManager.getTokenKeys();
+        const cachedAccessToken = this.cacheManager.getAccessToken(
+            request.account,
+            request,
+            tokenKeys,
+            requestTenantId
+        );
+
+        if (!cachedAccessToken) {
+            // must refresh due to non-existent access_token
+            this.setCacheOutcome(
+                CacheOutcome.NO_CACHED_ACCESS_TOKEN,
+                request.correlationId
+            );
+            throw createClientAuthError(
+                ClientAuthErrorCodes.tokenRefreshRequired
+            );
+        } else if (
+            TimeUtils.wasClockTurnedBack(cachedAccessToken.cachedAt) ||
+            TimeUtils.isTokenExpired(
+                cachedAccessToken.expiresOn,
+                this.config.systemOptions.tokenRenewalOffsetSeconds
+            )
+        ) {
+            // must refresh due to the expires_in value
+            this.setCacheOutcome(
+                CacheOutcome.CACHED_ACCESS_TOKEN_EXPIRED,
+                request.correlationId
+            );
+            throw createClientAuthError(
+                ClientAuthErrorCodes.tokenRefreshRequired
+            );
+        } else if (request.resource) {
+            // cached access token must have a resource that matches the request resource for MCP scenarios
+            if (cachedAccessToken.resource !== request.resource) {
+                this.setCacheOutcome(
+                    CacheOutcome.NO_CACHED_ACCESS_TOKEN,
+                    request.correlationId
+                );
+                throw createClientAuthError(
+                    ClientAuthErrorCodes.tokenRefreshRequired
+                );
+            }
+        } else if (
+            cachedAccessToken.refreshOn &&
+            TimeUtils.isTokenExpired(cachedAccessToken.refreshOn, 0)
+        ) {
+            // must refresh (in the background) due to the refresh_in value
+            lastCacheOutcome = CacheOutcome.PROACTIVELY_REFRESHED;
+
+            // don't throw ClientAuthError.createRefreshRequiredError(), return cached token instead
+        }
+
+        const environment =
+            request.authority || this.authority.getPreferredCache();
+        const cacheRecord: CacheRecord = {
+            account: this.cacheManager.getAccount(
+                this.cacheManager.generateAccountKey(request.account),
+                request.correlationId
+            ),
+            accessToken: cachedAccessToken,
+            idToken: this.cacheManager.getIdToken(
+                request.account,
+                request.correlationId,
+                tokenKeys,
+                requestTenantId
+            ),
+            refreshToken: null,
+            appMetadata: this.cacheManager.readAppMetadataFromCache(
+                environment,
+                request.correlationId
+            ),
+        };
+
+        this.setCacheOutcome(lastCacheOutcome, request.correlationId);
+
+        if (this.config.serverTelemetryManager) {
+            this.config.serverTelemetryManager.incrementCacheHits();
+        }
+
+        return [
+            await invokeAsync(
+                this.generateResultFromCacheRecord.bind(this),
+                PerformanceEvents.SilentFlowClientGenerateResultFromCacheRecord,
+                this.logger,
+                this.performanceClient,
+                request.correlationId
+            )(cacheRecord, request),
+            lastCacheOutcome,
+        ];
+    }
+
+    private setCacheOutcome(
+        cacheOutcome: CacheOutcome,
+        correlationId: string
+    ): void {
+        this.serverTelemetryManager?.setCacheOutcome(cacheOutcome);
+        this.performanceClient?.addFields(
+            {
+                cacheOutcome: cacheOutcome,
+            },
+            correlationId
+        );
+        if (cacheOutcome !== CacheOutcome.NOT_APPLICABLE) {
+            this.logger.info(
+                `Token refresh is required due to cache outcome: '${cacheOutcome}'`,
+                correlationId
+            );
+        }
+    }
+
+    /**
+     * Helper function to build response object from the CacheRecord
+     * @param cacheRecord
+     */
+    private async generateResultFromCacheRecord(
+        cacheRecord: CacheRecord,
+        request: CommonSilentFlowRequest
+    ): Promise<AuthenticationResult> {
+        let idTokenClaims: TokenClaims | undefined;
+        if (cacheRecord.idToken) {
+            idTokenClaims = extractTokenClaims(
+                cacheRecord.idToken.secret,
+                this.config.cryptoInterface.base64Decode
+            );
+        }
+
+        // token max_age check
+        if (request.maxAge || request.maxAge === 0) {
+            const authTime = idTokenClaims?.auth_time;
+            if (!authTime) {
+                throw createClientAuthError(
+                    ClientAuthErrorCodes.authTimeNotFound
+                );
+            }
+
+            checkMaxAge(authTime, request.maxAge);
+        }
+
+        return ResponseHandler.generateAuthenticationResult(
+            this.cryptoUtils,
+            this.authority,
+            cacheRecord,
+            true,
+            request,
+            this.performanceClient,
+            idTokenClaims
+        );
+    }
+}

package/dist/tedious/node_modules/@azure/msal-browser/node_modules/@azure/msal-common/src/config/AppTokenProvider.ts

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+/**
+ * Extensibility interface, which allows the app developer to return a token, based on the passed-in parameters, instead of fetching tokens from
+ * the Identity Provider (AAD).
+ * Developers need to construct and return an AppTokenProviderResult object back to MSAL. MSAL will cache the token response
+ * in the same way it would do if the result were comming from AAD.
+ * This extensibility point is only defined for the client_credential flow, i.e. acquireTokenByClientCredential and
+ * meant for Azure SDK to enhance Managed Identity support.
+ */
+export interface IAppTokenProvider {
+    (
+        appTokenProviderParameters: AppTokenProviderParameters
+    ): Promise<AppTokenProviderResult>;
+}
+
+/**
+ * Input object for the IAppTokenProvider extensiblity. MSAL will create this object, which can be used
+ * to help create an AppTokenProviderResult.
+ *
+ * - correlationId           - the correlation Id associated with the request
+ * - tenantId                - the tenant Id for which the token must be provided
+ * - scopes                  - the scopes for which the token must be provided
+ * - claims                  - any extra claims that the token must satisfy
+ */
+export type AppTokenProviderParameters = {
+    readonly correlationId?: string;
+    readonly tenantId: string;
+    readonly scopes: Array<string>;
+    readonly claims?: string;
+};
+
+/**
+ * Output object for IAppTokenProvider extensiblity.
+ *
+ * - accessToken            - the actual access token, typically in JWT format, that satisfies the request data AppTokenProviderParameters
+ * - expiresInSeconds       - how long the tokens has before expiry, in seconds. Similar to the "expires_in" field in an AAD token response.
+ * - refreshInSeconds       - how long the token has before it should be proactively refreshed. Similar to the "refresh_in" field in an AAD token response.
+ */
+export type AppTokenProviderResult = {
+    accessToken: string;
+    expiresInSeconds: number;
+    refreshInSeconds?: number;
+};

package/dist/tedious/node_modules/@azure/msal-browser/node_modules/@azure/msal-common/src/config/ClientConfiguration.ts

@@ -0,0 +1,277 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { INetworkModule } from "../network/INetworkModule.js";
+import { DEFAULT_CRYPTO_IMPLEMENTATION, ICrypto } from "../crypto/ICrypto.js";
+import { ILoggerCallback, Logger, LogLevel } from "../logger/Logger.js";
+import {
+    DEFAULT_COMMON_TENANT,
+    DEFAULT_TOKEN_RENEWAL_OFFSET_SEC,
+    SKU,
+} from "../utils/Constants.js";
+import { version } from "../packageMetadata.js";
+import type { Authority } from "../authority/Authority.js";
+import { AzureCloudInstance } from "../authority/AuthorityOptions.js";
+import { CacheManager, DefaultStorageClass } from "../cache/CacheManager.js";
+import { ServerTelemetryManager } from "../telemetry/server/ServerTelemetryManager.js";
+import { ICachePlugin } from "../cache/interface/ICachePlugin.js";
+import { ISerializableTokenCache } from "../cache/interface/ISerializableTokenCache.js";
+import { ClientCredentials } from "../account/ClientCredentials.js";
+import { ProtocolMode } from "../authority/ProtocolMode.js";
+import {
+    ClientAuthErrorCodes,
+    createClientAuthError,
+} from "../error/ClientAuthError.js";
+import { StubPerformanceClient } from "../telemetry/performance/StubPerformanceClient.js";
+
+/**
+ * Use the configuration object to configure MSAL Modules and initialize the base interfaces for MSAL.
+ *
+ * This object allows you to configure important elements of MSAL functionality:
+ * - authOptions                - Authentication for application
+ * - cryptoInterface            - Implementation of crypto functions
+ * - libraryInfo                - Library metadata
+ * - telemetry                  - Telemetry options and data
+ * - loggerOptions              - Logging for application
+ * - networkInterface           - Network implementation
+ * - storageInterface           - Storage implementation
+ * - systemOptions              - Additional library options
+ * - clientCredentials          - Credentials options for confidential clients
+ * @internal
+ */
+export type ClientConfiguration = {
+    authOptions: AuthOptions;
+    systemOptions?: SystemOptions;
+    loggerOptions?: LoggerOptions;
+    storageInterface?: CacheManager;
+    networkInterface?: INetworkModule;
+    cryptoInterface?: ICrypto;
+    clientCredentials?: ClientCredentials;
+    libraryInfo?: LibraryInfo;
+    telemetry?: TelemetryOptions;
+    serverTelemetryManager?: ServerTelemetryManager | null;
+    persistencePlugin?: ICachePlugin | null;
+    serializableCache?: ISerializableTokenCache | null;
+};
+
+export type CommonClientConfiguration = {
+    authOptions: Required<AuthOptions>;
+    systemOptions: Required<SystemOptions>;
+    loggerOptions: Required<LoggerOptions>;
+    storageInterface: CacheManager;
+    networkInterface: INetworkModule;
+    cryptoInterface: Required<ICrypto>;
+    libraryInfo: LibraryInfo;
+    telemetry: Required<TelemetryOptions>;
+    serverTelemetryManager: ServerTelemetryManager | null;
+    clientCredentials: ClientCredentials;
+    persistencePlugin: ICachePlugin | null;
+    serializableCache: ISerializableTokenCache | null;
+};
+
+/**
+ * Use this to configure the auth options in the ClientConfiguration object
+ *
+ * - clientId                    - Client ID of your app registered with our Application registration portal : https://portal.azure.com/#blade/Microsoft_AAD_IAM/ActiveDirectoryMenuBlade/RegisteredAppsPreview in Microsoft Identity Platform
+ * - authority                   - You can configure a specific authority, defaults to " " or "https://login.microsoftonline.com/common"
+ * - knownAuthorities            - An array of URIs that are known to be valid. Used in B2C scenarios.
+ * - cloudDiscoveryMetadata      - A string containing the cloud discovery response. Used in AAD scenarios.
+ * - clientCapabilities          - Array of capabilities which will be added to the claims.access_token.xms_cc request property on every network request.
+ * - instanceAware               - A flag of whether the STS will send back additional parameters to specify where the tokens should be retrieved from.
+ * - redirectUri                 - The redirect URI where authentication responses can be received by your application. It must exactly match one of the redirect URIs registered in the Azure portal.
+ * - isMcp                       - A flag of whether the application is an MCP application, which requires a resource parameter to be sent in token requests.
+ * @internal
+ */
+export type AuthOptions = {
+    clientId: string;
+    authority: Authority;
+    redirectUri: string;
+    clientCapabilities?: Array<string>;
+    azureCloudOptions?: AzureCloudOptions;
+    instanceAware?: boolean;
+    isMcp?: boolean;
+};
+
+/**
+ * Use this to configure token renewal info in the Configuration object
+ *
+ * - tokenRenewalOffsetSeconds    - Sets the window of offset needed to renew the token before expiry
+ * - protocolMode                - Enum that represents the protocol that msal follows. Used for configuring proper endpoints.
+ */
+export type SystemOptions = {
+    tokenRenewalOffsetSeconds?: number;
+    preventCorsPreflight?: boolean;
+};
+
+/**
+ *  Use this to configure the logging that MSAL does, by configuring logger options in the Configuration object
+ *
+ * - loggerCallback                - Callback for logger
+ * - piiLoggingEnabled             - Sets whether pii logging is enabled
+ * - logLevel                      - Sets the level at which logging happens
+ * - correlationId                 - Sets the correlationId printed by the logger
+ */
+export type LoggerOptions = {
+    loggerCallback?: ILoggerCallback;
+    piiLoggingEnabled?: boolean;
+    logLevel?: LogLevel;
+    correlationId?: string;
+};
+
+/**
+ * Library-specific options
+ */
+export type LibraryInfo = {
+    sku: string;
+    version: string;
+    cpu: string;
+    os: string;
+};
+
+/**
+ * AzureCloudInstance specific options
+ *
+ * - azureCloudInstance             - string enum providing short notation for soverign and public cloud authorities
+ * - tenant                         - provision to provide the tenant info
+ */
+export type AzureCloudOptions = {
+    azureCloudInstance: AzureCloudInstance;
+    tenant?: string;
+};
+
+export type TelemetryOptions = {
+    application: ApplicationTelemetry;
+};
+
+/**
+ * Telemetry information sent on request
+ * - appName: Unique string name of an application
+ * - appVersion: Version of the application using MSAL
+ */
+export type ApplicationTelemetry = {
+    appName: string;
+    appVersion: string;
+};
+
+export const DEFAULT_SYSTEM_OPTIONS: Required<SystemOptions> = {
+    tokenRenewalOffsetSeconds: DEFAULT_TOKEN_RENEWAL_OFFSET_SEC,
+    preventCorsPreflight: false,
+};
+
+const DEFAULT_LOGGER_IMPLEMENTATION: Required<LoggerOptions> = {
+    loggerCallback: () => {
+        // allow users to not set loggerCallback
+    },
+    piiLoggingEnabled: false,
+    logLevel: LogLevel.Info,
+    correlationId: "",
+};
+
+const DEFAULT_NETWORK_IMPLEMENTATION: INetworkModule = {
+    async sendGetRequestAsync<T>(): Promise<T> {
+        throw createClientAuthError(ClientAuthErrorCodes.methodNotImplemented);
+    },
+    async sendPostRequestAsync<T>(): Promise<T> {
+        throw createClientAuthError(ClientAuthErrorCodes.methodNotImplemented);
+    },
+};
+
+const DEFAULT_LIBRARY_INFO: LibraryInfo = {
+    sku: SKU,
+    version: version,
+    cpu: "",
+    os: "",
+};
+
+const DEFAULT_CLIENT_CREDENTIALS: ClientCredentials = {
+    clientSecret: "",
+    clientAssertion: undefined,
+};
+
+const DEFAULT_AZURE_CLOUD_OPTIONS: AzureCloudOptions = {
+    azureCloudInstance: AzureCloudInstance.None,
+    tenant: `${DEFAULT_COMMON_TENANT}`,
+};
+
+const DEFAULT_TELEMETRY_OPTIONS: Required<TelemetryOptions> = {
+    application: {
+        appName: "",
+        appVersion: "",
+    },
+};
+
+/**
+ * Function that sets the default options when not explicitly configured from app developer
+ *
+ * @param Configuration
+ *
+ * @returns Configuration
+ */
+export function buildClientConfiguration({
+    authOptions: userAuthOptions,
+    systemOptions: userSystemOptions,
+    loggerOptions: userLoggerOption,
+    storageInterface: storageImplementation,
+    networkInterface: networkImplementation,
+    cryptoInterface: cryptoImplementation,
+    clientCredentials: clientCredentials,
+    libraryInfo: libraryInfo,
+    telemetry: telemetry,
+    serverTelemetryManager: serverTelemetryManager,
+    persistencePlugin: persistencePlugin,
+    serializableCache: serializableCache,
+}: ClientConfiguration): CommonClientConfiguration {
+    const loggerOptions = {
+        ...DEFAULT_LOGGER_IMPLEMENTATION,
+        ...userLoggerOption,
+    };
+
+    return {
+        authOptions: buildAuthOptions(userAuthOptions),
+        systemOptions: { ...DEFAULT_SYSTEM_OPTIONS, ...userSystemOptions },
+        loggerOptions: loggerOptions,
+        storageInterface:
+            storageImplementation ||
+            new DefaultStorageClass(
+                userAuthOptions.clientId,
+                DEFAULT_CRYPTO_IMPLEMENTATION,
+                new Logger(loggerOptions),
+                new StubPerformanceClient()
+            ),
+        networkInterface:
+            networkImplementation || DEFAULT_NETWORK_IMPLEMENTATION,
+        cryptoInterface: cryptoImplementation || DEFAULT_CRYPTO_IMPLEMENTATION,
+        clientCredentials: clientCredentials || DEFAULT_CLIENT_CREDENTIALS,
+        libraryInfo: { ...DEFAULT_LIBRARY_INFO, ...libraryInfo },
+        telemetry: { ...DEFAULT_TELEMETRY_OPTIONS, ...telemetry },
+        serverTelemetryManager: serverTelemetryManager || null,
+        persistencePlugin: persistencePlugin || null,
+        serializableCache: serializableCache || null,
+    };
+}
+
+/**
+ * Construct authoptions from the client and platform passed values
+ * @param authOptions
+ */
+function buildAuthOptions(authOptions: AuthOptions): Required<AuthOptions> {
+    return {
+        clientCapabilities: [],
+        azureCloudOptions: DEFAULT_AZURE_CLOUD_OPTIONS,
+        instanceAware: false,
+        isMcp: false,
+        ...authOptions,
+    };
+}
+
+/**
+ * Returns true if config has protocolMode set to ProtocolMode.OIDC, false otherwise
+ * @param ClientConfiguration
+ */
+export function isOidcProtocolMode(config: ClientConfiguration): boolean {
+    return (
+        config.authOptions.authority.options.protocolMode === ProtocolMode.OIDC
+    );
+}

package/dist/tedious/node_modules/@azure/msal-browser/node_modules/@azure/msal-common/src/constants/AADServerParamKeys.ts

@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+export const CLIENT_ID = "client_id";
+export const REDIRECT_URI = "redirect_uri";
+export const RESPONSE_TYPE = "response_type";
+export const RESPONSE_MODE = "response_mode";
+export const GRANT_TYPE = "grant_type";
+export const CLAIMS = "claims";
+export const SCOPE = "scope";
+export const ERROR = "error";
+export const ERROR_DESCRIPTION = "error_description";
+export const ACCESS_TOKEN = "access_token";
+export const ID_TOKEN = "id_token";
+export const REFRESH_TOKEN = "refresh_token";
+export const EXPIRES_IN = "expires_in";
+export const REFRESH_TOKEN_EXPIRES_IN = "refresh_token_expires_in";
+export const STATE = "state";
+export const NONCE = "nonce";
+export const PROMPT = "prompt";
+export const SESSION_STATE = "session_state";
+export const CLIENT_INFO = "client_info";
+export const CODE = "code";
+export const CODE_CHALLENGE = "code_challenge";
+export const CODE_CHALLENGE_METHOD = "code_challenge_method";
+export const CODE_VERIFIER = "code_verifier";
+export const CLIENT_REQUEST_ID = "client-request-id";
+export const X_CLIENT_SKU = "x-client-SKU";
+export const X_CLIENT_VER = "x-client-VER";
+export const X_CLIENT_OS = "x-client-OS";
+export const X_CLIENT_CPU = "x-client-CPU";
+export const X_CLIENT_CURR_TELEM = "x-client-current-telemetry";
+export const X_CLIENT_LAST_TELEM = "x-client-last-telemetry";
+export const X_MS_LIB_CAPABILITY = "x-ms-lib-capability";
+export const X_APP_NAME = "x-app-name";
+export const X_APP_VER = "x-app-ver";
+export const POST_LOGOUT_URI = "post_logout_redirect_uri";
+export const ID_TOKEN_HINT = "id_token_hint";
+export const DEVICE_CODE = "device_code";
+export const CLIENT_SECRET = "client_secret";
+export const CLIENT_ASSERTION = "client_assertion";
+export const CLIENT_ASSERTION_TYPE = "client_assertion_type";
+export const TOKEN_TYPE = "token_type";
+export const REQ_CNF = "req_cnf";
+export const OBO_ASSERTION = "assertion";
+export const REQUESTED_TOKEN_USE = "requested_token_use";
+export const ON_BEHALF_OF = "on_behalf_of";
+export const FOCI = "foci";
+export const CCS_HEADER = "X-AnchorMailbox";
+export const RETURN_SPA_CODE = "return_spa_code";
+export const NATIVE_BROKER = "nativebroker";
+export const LOGOUT_HINT = "logout_hint";
+export const SID = "sid";
+export const LOGIN_HINT = "login_hint";
+export const DOMAIN_HINT = "domain_hint";
+export const X_CLIENT_EXTRA_SKU = "x-client-xtra-sku";
+export const BROKER_CLIENT_ID = "brk_client_id";
+export const BROKER_REDIRECT_URI = "brk_redirect_uri";
+export const INSTANCE_AWARE = "instance_aware";
+export const EAR_JWK = "ear_jwk";
+export const EAR_JWE_CRYPTO = "ear_jwe_crypto";
+export const RESOURCE = "resource";
+export const CLI_DATA = "clidata";