@dereekb/calcom 13.32.0 → 13.34.0

package/index.cjs.js

@@ -1338,10 +1338,7 @@ function _ts_generator$1(thisArg, body) {
         };
         // MARK: Make User Context
         var makeUserContext = function makeUserContext(input) {
-            var userAccessTokenFactory = oauthContext.makeUserAccessTokenFactory({
-                refreshToken: input.refreshToken,
-                userAccessTokenCache: input.accessTokenCache
-            });
+            var userAccessTokenFactory = oauthContext.makeAccessTokenFactory(input);
             var userAccessTokenStringFactory = calcomAccessTokenStringFactory(userAccessTokenFactory);
             var userBaseFetch = fetchFactory({
                 calcomAccessTokenStringFactory: userAccessTokenStringFactory
@@ -1816,6 +1813,62 @@ var CALCOM_API_VERSION_HEADER = 'cal-api-version';
     };
 }
 
+/**
+ * The Cal.com OAuth API base URL.
+ *
+ * Endpoint paths are appended to this base, so it intentionally carries no endpoint segment of
+ * its own. This is the single place the OAuth host and prefix are encoded.
+ */ var CALCOM_OAUTH_API_URL = 'https://api.cal.com/v2/auth/oauth2';
+/**
+ * The Cal.com OAuth token endpoint path, relative to {@link CALCOM_OAUTH_API_URL}.
+ */ var CALCOM_OAUTH_TOKEN_PATH = '/token';
+/**
+ * The Cal.com OAuth authorize URL.
+ */ var CALCOM_OAUTH_AUTHORIZE_URL = 'https://app.cal.com/auth/oauth2/authorize';
+/**
+ * Returns whether the credential is a {@link CalcomApiKeyCredential}.
+ *
+ * @param credential - The credential to check.
+ * @returns True when the credential carries an api key.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */ function isCalcomApiKeyCredential(credential) {
+    return 'apiKey' in credential;
+}
+/**
+ * Builds a {@link CalcomAuthCredential} from flat, optional values, as an environment-facing
+ * configuration provides them.
+ *
+ * An api key wins when both are present: it does not expire, so it skips the refresh loop entirely.
+ * The cache attaches only to the refresh-token arm, since an api key has no token to cache. Empty
+ * strings count as absent, so an unset environment variable read as `''` does not become a
+ * credential that sends `Bearer `.
+ *
+ * @param values - The flat credential values.
+ * @returns The equivalent credential, or undefined when neither value is present.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */ function calcomAuthCredentialFromValues(values) {
+    var apiKey = values.apiKey, refreshToken = values.refreshToken, accessTokenCache = values.accessTokenCache;
+    var result;
+    if (apiKey) {
+        result = {
+            apiKey: apiKey
+        };
+    } else if (refreshToken) {
+        result = {
+            refreshToken: refreshToken,
+            accessTokenCache: accessTokenCache
+        };
+    }
+    return result;
+}
+// COMPAT: Deprecated aliases
+/**
+ * @deprecated use {@link CALCOM_OAUTH_API_URL} instead. This was previously used as the fetch base
+ * URL while the endpoint path `/oauth/token` was also appended, resolving to a doubly-pathed URL.
+ */ var CALCOM_OAUTH_TOKEN_URL = "".concat(CALCOM_OAUTH_API_URL).concat(CALCOM_OAUTH_TOKEN_PATH);
+
 /**
  * Refreshes an access token using a refresh token. Cal.com rotates refresh tokens
  * on every use, so the new `refresh_token` from the response must be persisted.
@@ -1823,7 +1876,7 @@ var CALCOM_API_VERSION_HEADER = 'cal-api-version';
  * Cal.com uses JSON body (not Basic Auth) for token requests.
  *
  * @param context - The Cal.com OAuth context providing client credentials and fetch capabilities.
- * @returns Refreshes an access token using an optional refresh token override.
+ * @returns Refreshes an access token using the given refresh token.
  *
  * @see https://cal.com/docs/api-reference/v2/oauth/refresh-an-existing-access-token
  *
@@ -1833,19 +1886,18 @@ var CALCOM_API_VERSION_HEADER = 'cal-api-version';
  * console.log(response.access_token, response.refresh_token);
  * ```
  */ function refreshAccessToken(context) {
+    var client = context.config.client;
     return function(input) {
-        var _ref;
-        var refreshToken = (_ref = input === null || input === void 0 ? void 0 : input.refreshToken) !== null && _ref !== void 0 ? _ref : context.config.refreshToken;
         var fetchJsonInput = {
             method: 'POST',
             body: JSON.stringify({
                 grant_type: 'refresh_token',
-                client_id: context.config.clientId,
-                client_secret: context.config.clientSecret,
-                refresh_token: refreshToken
+                client_id: client === null || client === void 0 ? void 0 : client.clientId,
+                client_secret: client === null || client === void 0 ? void 0 : client.clientSecret,
+                refresh_token: input.refreshToken
             })
         };
-        return context.fetchJson('/oauth/token', fetchJsonInput);
+        return context.fetchJson(CALCOM_OAUTH_TOKEN_PATH, fetchJsonInput);
     };
 }
 /**
@@ -1868,27 +1920,102 @@ var CALCOM_API_VERSION_HEADER = 'cal-api-version';
  * console.log(response.access_token, response.refresh_token);
  * ```
  */ function exchangeAuthorizationCode(context) {
+    var client = context.config.client;
     return function(input) {
         var fetchJsonInput = {
             method: 'POST',
             body: JSON.stringify({
                 grant_type: 'authorization_code',
-                client_id: context.config.clientId,
-                client_secret: context.config.clientSecret,
+                client_id: client === null || client === void 0 ? void 0 : client.clientId,
+                client_secret: client === null || client === void 0 ? void 0 : client.clientSecret,
                 code: input.code,
                 redirect_uri: input.redirectUri
             })
         };
-        return context.fetchJson('/oauth/token', fetchJsonInput);
+        return context.fetchJson(CALCOM_OAUTH_TOKEN_PATH, fetchJsonInput);
     };
 }
 
 /**
- * The Cal.com OAuth token endpoint URL.
- */ var CALCOM_OAUTH_TOKEN_URL = 'https://api.cal.com/v2/oauth/token';
+ * Every granular Cal.com OAuth scope.
+ *
+ * A runtime list rather than a bare type union, so a configured scope can be validated instead of
+ * being passed through to the consent screen and refused there.
+ *
+ * @see https://cal.com/docs/api-reference/v2/oauth
+ */ var ALL_CALCOM_OAUTH_SCOPES = [
+    'PROFILE_READ',
+    'PROFILE_WRITE',
+    'BOOKING_READ',
+    'BOOKING_WRITE',
+    'SCHEDULE_READ',
+    'SCHEDULE_WRITE',
+    'EVENT_TYPE_READ',
+    'EVENT_TYPE_WRITE',
+    'APPS_READ',
+    'APPS_WRITE',
+    'WEBHOOK_READ',
+    'WEBHOOK_WRITE'
+];
 /**
- * The Cal.com OAuth authorize URL.
- */ var CALCOM_OAUTH_AUTHORIZE_URL = 'https://app.cal.com/auth/oauth2/authorize';
+ * Returns whether the input is a known {@link CalcomOAuthScope}.
+ *
+ * @param value - The value to check.
+ * @returns True when the value is a known Cal.com OAuth scope.
+ */ function isCalcomOAuthScope(value) {
+    return ALL_CALCOM_OAUTH_SCOPES.includes(value);
+}
+/**
+ * The delimiter used to join scopes in the `scope` query parameter.
+ *
+ * OAuth2 specifies a space-delimited list. Cal.com's granular scopes are documented without an
+ * explicit delimiter, so this is isolated here: if the consent screen rejects the `scope`
+ * parameter, this is the only value that needs to change.
+ */ var CALCOM_OAUTH_SCOPE_DELIMITER = ' ';
+/**
+ * The `response_type` used by the authorization-code flow.
+ */ var CALCOM_OAUTH_AUTHORIZE_RESPONSE_TYPE = 'code';
+/**
+ * Creates a {@link CalcomOAuthAuthorizeUrlFactory} that composes the Cal.com authorize URL that a
+ * user's browser is redirected to in order to begin the authorization-code flow.
+ *
+ * The client id, redirect URI, and scopes are fixed by the config, since a consumer holds those
+ * constant and varies only the per-request `state`.
+ *
+ * @param config - The client id, redirect URI, and scopes to request.
+ * @returns A factory that builds an authorize URL for the given params.
+ *
+ * @see https://cal.com/docs/api-reference/v2/oauth
+ *
+ * @example
+ * ```ts
+ * const authorizeUrlFactory = calcomOAuthAuthorizeUrlFactory({
+ *   clientId: 'client-id',
+ *   redirectUri: 'http://localhost:9901/oauth/calcom/callback',
+ *   scopes: ['PROFILE_READ', 'BOOKING_READ']
+ * });
+ *
+ * const url = authorizeUrlFactory({ state: 'signed-state' });
+ * ```
+ *
+ * @__NO_SIDE_EFFECTS__
+ */ function calcomOAuthAuthorizeUrlFactory(config) {
+    var clientId = config.clientId, redirectUri = config.redirectUri, scopes = config.scopes, inputAuthorizeUrl = config.authorizeUrl;
+    var authorizeUrl = inputAuthorizeUrl !== null && inputAuthorizeUrl !== void 0 ? inputAuthorizeUrl : CALCOM_OAUTH_AUTHORIZE_URL;
+    var scope = scopes.join(CALCOM_OAUTH_SCOPE_DELIMITER);
+    return function(params) {
+        var url = new URL(authorizeUrl);
+        var state = params === null || params === void 0 ? void 0 : params.state;
+        url.searchParams.set('client_id', clientId);
+        url.searchParams.set('redirect_uri', redirectUri);
+        url.searchParams.set('response_type', CALCOM_OAUTH_AUTHORIZE_RESPONSE_TYPE);
+        url.searchParams.set('scope', scope);
+        if (state != null) {
+            url.searchParams.set('state', state);
+        }
+        return url.toString();
+    };
+}
 
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
     try {
@@ -2018,6 +2145,54 @@ function _ts_generator(thisArg, body) {
         };
     }
 }
+/**
+ * Maps a {@link CalcomOAuthTokenResponse} to a {@link CalcomAccessToken}.
+ *
+ * Pure: the caller owns the rotated refresh token that comes back on the result, so each token
+ * scope (server-level vs per-user) tracks its own rotation instead of sharing one variable.
+ *
+ * @param response - The token response returned by the Cal.com token endpoint.
+ * @returns The equivalent CalcomAccessToken, with `expiresAt` resolved against the current time.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */ function calcomAccessTokenFromTokenResponse(response) {
+    var createdAt = Date.now();
+    var access_token = response.access_token, refresh_token = response.refresh_token, scope = response.scope, expires_in = response.expires_in;
+    var accessToken = {
+        accessToken: access_token,
+        refreshToken: refresh_token,
+        expiresIn: expires_in,
+        expiresAt: new Date(createdAt + expires_in * util.MS_IN_SECOND),
+        scope: scope !== null && scope !== void 0 ? scope : ''
+    };
+    return accessToken;
+}
+/**
+ * The lifetime given to the synthetic access token an api key is wrapped in.
+ *
+ * Cal.com api keys do not expire; the value only has to outlive any process holding one, so the
+ * token satisfies the same expiration check every other token goes through.
+ */ var CALCOM_API_KEY_ACCESS_TOKEN_EXPIRATION = util.MS_IN_DAY * 365 * 100;
+/**
+ * Wraps a {@link CalcomApiKey} as a static {@link CalcomAccessToken}.
+ *
+ * An api key is already a bearer token acting as the user who created it, so there is nothing to
+ * exchange and nothing to refresh.
+ *
+ * @param apiKey - The Cal.com api key.
+ * @returns The equivalent static CalcomAccessToken.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */ function calcomAccessTokenFromApiKey(apiKey) {
+    var accessToken = {
+        accessToken: apiKey,
+        refreshToken: '',
+        expiresIn: Number.MAX_SAFE_INTEGER,
+        expiresAt: new Date(Date.now() + CALCOM_API_KEY_ACCESS_TOKEN_EXPIRATION),
+        scope: ''
+    };
+    return accessToken;
+}
 /**
  * Creates a {@link CalcomOAuthFactory} that produces configured Cal.com OAuth instances.
  * Supports both API key authentication (static token, no refresh) and full OAuth
@@ -2028,10 +2203,11 @@ function _ts_generator(thisArg, body) {
  *
  * @__NO_SIDE_EFFECTS__
  */ function calcomOAuthFactory(factoryConfig) {
-    var fetchHandler = calcomRateLimitedFetchHandler();
+    var _factoryConfig_fetchHandler;
+    var fetchHandler = (_factoryConfig_fetchHandler = factoryConfig.fetchHandler) !== null && _factoryConfig_fetchHandler !== void 0 ? _factoryConfig_fetchHandler : calcomRateLimitedFetchHandler();
     var logCalcomServerErrorFunction = factoryConfig.logCalcomServerErrorFunction, _factoryConfig_fetchFactory = factoryConfig.fetchFactory, fetchFactory = _factoryConfig_fetchFactory === void 0 ? function(_) {
         return fetch.fetchApiFetchService.makeFetch({
-            baseUrl: CALCOM_OAUTH_TOKEN_URL,
+            baseUrl: CALCOM_OAUTH_API_URL,
             baseRequest: {
                 headers: {
                     'Content-Type': 'application/json'
@@ -2044,138 +2220,100 @@ function _ts_generator(thisArg, body) {
         });
     } : _factoryConfig_fetchFactory;
     return function(config) {
-        var accessTokenFromTokenResponse = function accessTokenFromTokenResponse(result) {
-            var createdAt = Date.now();
-            var access_token = result.access_token, refresh_token = result.refresh_token, scope = result.scope, expires_in = result.expires_in;
-            // Store the new refresh token for next use
-            latestRefreshToken = refresh_token;
-            var accessToken = {
-                accessToken: access_token,
-                refreshToken: refresh_token,
-                expiresIn: expires_in,
-                expiresAt: new Date(createdAt + expires_in * util.MS_IN_SECOND),
-                scope: scope !== null && scope !== void 0 ? scope : ''
-            };
-            return accessToken;
-        };
-        var useApiKey = !!config.apiKey;
-        if (!useApiKey) {
-            if (!config.clientId) {
-                throw new Error('CalcomOAuthConfig missing clientId. Provide clientId+clientSecret for OAuth or apiKey for API key auth.');
-            } else if (!config.clientSecret) {
-                throw new Error('CalcomOAuthConfig missing clientSecret.');
-            }
+        var defaultAuth = config.defaultAuth, client = config.client;
+        var hasApiKeyDefault = defaultAuth != null && isCalcomApiKeyCredential(defaultAuth) && !!defaultAuth.apiKey;
+        // an API key IS the token; every other credential is an exchange the token endpoint authenticates
+        // with the client id and secret. With neither, no token could ever be produced
+        if (!hasApiKeyDefault && client == null) {
+            throw new Error('CalcomOAuthConfig can authenticate nothing. Provide `defaultAuth: { apiKey }` for ambient calls, `client` (clientId+clientSecret) to exchange any refresh token, or both.');
         }
         var baseFetch = fetchFactory();
         var fetch$1 = handleCalcomOAuthErrorFetch(baseFetch, logCalcomServerErrorFunction);
         var fetchJson = fetch.fetchJsonFunction(fetch$1, {
             handleFetchJsonParseErrorFunction: fetch.returnNullHandleFetchJsonParseErrorFunction
         });
-        // MARK: API Key Auth (static token, no refresh)
-        if (useApiKey) {
-            var apiKeyToken = {
-                accessToken: config.apiKey,
-                refreshToken: '',
-                expiresIn: Number.MAX_SAFE_INTEGER,
-                expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24 * 365 * 100),
-                scope: ''
-            };
-            var loadAccessToken = function loadAccessToken() {
-                return _async_to_generator(function() {
-                    return _ts_generator(this, function(_state) {
-                        return [
-                            2,
-                            apiKeyToken
-                        ];
-                    });
-                })();
-            };
-            var makeUserAccessTokenFactory = function makeUserAccessTokenFactory() {
-                throw new Error('makeUserAccessTokenFactory is not available when using API key auth. Use OAuth for per-user contexts.');
-            };
-            var oauthContext = {
-                fetch: fetch$1,
-                fetchJson: fetchJson,
-                loadAccessToken: loadAccessToken,
-                makeUserAccessTokenFactory: makeUserAccessTokenFactory,
-                config: config
-            };
-            return {
-                oauthContext: oauthContext
-            };
-        }
-        // MARK: OAuth Auth (refresh token flow)
-        /**
-         * Tracks the latest refresh token since Cal.com rotates them.
-         */ var latestRefreshToken = config.refreshToken;
-        var tokenRefresher = function tokenRefresher() {
-            return _async_to_generator(function() {
-                var accessToken;
-                return _ts_generator(this, function(_state) {
-                    switch(_state.label){
-                        case 0:
-                            return [
-                                4,
-                                refreshAccessToken(oauthContext1)({
-                                    refreshToken: latestRefreshToken !== null && latestRefreshToken !== void 0 ? latestRefreshToken : undefined
-                                })
-                            ];
-                        case 1:
-                            accessToken = _state.sent();
+        // MARK: Access Tokens
+        var makeAccessTokenFactory = function makeAccessTokenFactory(credential) {
+            var result;
+            if (isCalcomApiKeyCredential(credential)) {
+                var apiKey = credential.apiKey;
+                // presence, not truthiness, is what discriminates the union — so without this an empty key
+                // would be handed back as a valid static token and every call would send `Bearer `
+                if (!apiKey) {
+                    throw new Error('CalcomApiKeyCredential.apiKey is empty.');
+                }
+                var apiKeyToken = calcomAccessTokenFromApiKey(apiKey);
+                result = function result() {
+                    return _async_to_generator(function() {
+                        return _ts_generator(this, function(_state) {
                             return [
                                 2,
-                                accessTokenFromTokenResponse(accessToken)
+                                apiKeyToken
                             ];
-                    }
+                        });
+                    })();
+                };
+            } else {
+                // a token for a specific grant can only come from that grant's refresh token, exchanged
+                // against the OAuth client. An API key is a different user's identity and cannot stand in
+                if (client == null) {
+                    throw new Error('makeAccessTokenFactory() requires a `client` (clientId+clientSecret) to exchange a refresh token credential. A Cal.com configuration with only an api key cannot create one.');
+                }
+                /**
+                 * Tracks THIS credential's rotated refresh token, since Cal.com rotates on every use.
+                 *
+                 * Declared per invocation, so every credential — the default one as much as any per-user one
+                 * — rotates in isolation and refreshing one never overwrites another's token.
+                 */ var latestRefreshToken = credential.refreshToken;
+                var tokenRefresher = function tokenRefresher() {
+                    return _async_to_generator(function() {
+                        var response, accessToken;
+                        return _ts_generator(this, function(_state) {
+                            switch(_state.label){
+                                case 0:
+                                    return [
+                                        4,
+                                        refreshAccessToken(oauthContext)({
+                                            refreshToken: latestRefreshToken
+                                        })
+                                    ];
+                                case 1:
+                                    response = _state.sent();
+                                    accessToken = calcomAccessTokenFromTokenResponse(response);
+                                    latestRefreshToken = accessToken.refreshToken;
+                                    return [
+                                        2,
+                                        accessToken
+                                    ];
+                            }
+                        });
+                    })();
+                };
+                result = calcomOAuthAccessTokenFactory({
+                    tokenRefresher: tokenRefresher,
+                    accessTokenCache: credential.accessTokenCache
                 });
-            })();
-        };
-        var loadAccessToken1 = calcomOAuthAccessTokenFactory({
-            tokenRefresher: tokenRefresher,
-            accessTokenCache: config.accessTokenCache
-        });
-        // User Access Token
-        var makeUserAccessTokenFactory1 = function makeUserAccessTokenFactory(input) {
-            var userLatestRefreshToken = input.refreshToken;
-            var userTokenRefresher = function userTokenRefresher() {
-                return _async_to_generator(function() {
-                    var tokenResponse, token;
-                    return _ts_generator(this, function(_state) {
-                        switch(_state.label){
-                            case 0:
-                                return [
-                                    4,
-                                    refreshAccessToken(oauthContext1)({
-                                        refreshToken: userLatestRefreshToken
-                                    })
-                                ];
-                            case 1:
-                                tokenResponse = _state.sent();
-                                token = accessTokenFromTokenResponse(tokenResponse);
-                                // Track the rotated refresh token for this user
-                                userLatestRefreshToken = token.refreshToken;
-                                return [
-                                    2,
-                                    token
-                                ];
-                        }
-                    });
-                })();
-            };
-            return calcomOAuthAccessTokenFactory({
-                tokenRefresher: userTokenRefresher,
-                accessTokenCache: input.userAccessTokenCache
-            });
+            }
+            return result;
         };
-        var oauthContext1 = {
+        // built once, so the default credential's in-memory tier and its rotation are shared across the
+        // whole context instead of restarting on every call
+        var loadAccessToken = defaultAuth == null ? function() {
+            return _async_to_generator(function() {
+                return _ts_generator(this, function(_state) {
+                    throw new CalcomOAuthAuthFailureError('No `defaultAuth` is configured on this CalcomOAuthConfig, so there is no ambient credential to authenticate with. Use makeAccessTokenFactory(credential) for a named credential.');
+                });
+            })();
+        } : makeAccessTokenFactory(defaultAuth);
+        var oauthContext = {
             fetch: fetch$1,
             fetchJson: fetchJson,
-            loadAccessToken: loadAccessToken1,
-            makeUserAccessTokenFactory: makeUserAccessTokenFactory1,
+            loadAccessToken: loadAccessToken,
+            makeAccessTokenFactory: makeAccessTokenFactory,
             config: config
         };
         var calcomOAuth = {
-            oauthContext: oauthContext1
+            oauthContext: oauthContext
         };
         return calcomOAuth;
     };
@@ -2289,6 +2427,8 @@ function _ts_generator(thisArg, body) {
     };
 }
 
+exports.ALL_CALCOM_OAUTH_SCOPES = ALL_CALCOM_OAUTH_SCOPES;
+exports.CALCOM_API_KEY_ACCESS_TOKEN_EXPIRATION = CALCOM_API_KEY_ACCESS_TOKEN_EXPIRATION;
 exports.CALCOM_API_URL = CALCOM_API_URL;
 exports.CALCOM_API_VERSION_BOOKINGS = CALCOM_API_VERSION_BOOKINGS;
 exports.CALCOM_API_VERSION_CALENDARS = CALCOM_API_VERSION_CALENDARS;
@@ -2297,8 +2437,12 @@ exports.CALCOM_API_VERSION_HEADER = CALCOM_API_VERSION_HEADER;
 exports.CALCOM_API_VERSION_ME = CALCOM_API_VERSION_ME;
 exports.CALCOM_API_VERSION_SCHEDULES = CALCOM_API_VERSION_SCHEDULES;
 exports.CALCOM_API_VERSION_SLOTS = CALCOM_API_VERSION_SLOTS;
+exports.CALCOM_OAUTH_API_URL = CALCOM_OAUTH_API_URL;
+exports.CALCOM_OAUTH_AUTHORIZE_RESPONSE_TYPE = CALCOM_OAUTH_AUTHORIZE_RESPONSE_TYPE;
 exports.CALCOM_OAUTH_AUTHORIZE_URL = CALCOM_OAUTH_AUTHORIZE_URL;
 exports.CALCOM_OAUTH_INVALID_GRANT_ERROR_CODE = CALCOM_OAUTH_INVALID_GRANT_ERROR_CODE;
+exports.CALCOM_OAUTH_SCOPE_DELIMITER = CALCOM_OAUTH_SCOPE_DELIMITER;
+exports.CALCOM_OAUTH_TOKEN_PATH = CALCOM_OAUTH_TOKEN_PATH;
 exports.CALCOM_OAUTH_TOKEN_URL = CALCOM_OAUTH_TOKEN_URL;
 exports.CALCOM_RATE_LIMIT_LIMIT_HEADER = CALCOM_RATE_LIMIT_LIMIT_HEADER;
 exports.CALCOM_RATE_LIMIT_REMAINING_HEADER = CALCOM_RATE_LIMIT_REMAINING_HEADER;
@@ -2312,10 +2456,14 @@ exports.CalcomTooManyRequestsError = CalcomTooManyRequestsError;
 exports.DEFAULT_CALCOM_API_RATE_LIMIT = DEFAULT_CALCOM_API_RATE_LIMIT;
 exports.DEFAULT_CALCOM_API_RATE_LIMIT_RESET_PERIOD = DEFAULT_CALCOM_API_RATE_LIMIT_RESET_PERIOD;
 exports.DEFAULT_CALCOM_RATE_LIMITED_TOO_MANY_REQUESTS_LOG_FUNCTION = DEFAULT_CALCOM_RATE_LIMITED_TOO_MANY_REQUESTS_LOG_FUNCTION;
+exports.calcomAccessTokenFromApiKey = calcomAccessTokenFromApiKey;
+exports.calcomAccessTokenFromTokenResponse = calcomAccessTokenFromTokenResponse;
 exports.calcomAccessTokenStringFactory = calcomAccessTokenStringFactory;
 exports.calcomApiVersionHeaders = calcomApiVersionHeaders;
+exports.calcomAuthCredentialFromValues = calcomAuthCredentialFromValues;
 exports.calcomFactory = calcomFactory;
 exports.calcomOAuthAccessTokenFactory = calcomOAuthAccessTokenFactory;
+exports.calcomOAuthAuthorizeUrlFactory = calcomOAuthAuthorizeUrlFactory;
 exports.calcomOAuthFactory = calcomOAuthFactory;
 exports.calcomRateLimitHeaderDetails = calcomRateLimitHeaderDetails;
 exports.calcomRateLimitedFetchHandler = calcomRateLimitedFetchHandler;
@@ -2338,6 +2486,8 @@ exports.getWebhooks = getWebhooks;
 exports.handleCalcomErrorFetch = handleCalcomErrorFetch;
 exports.handleCalcomErrorFetchFactory = handleCalcomErrorFetchFactory;
 exports.handleCalcomOAuthErrorFetch = handleCalcomOAuthErrorFetch;
+exports.isCalcomApiKeyCredential = isCalcomApiKeyCredential;
+exports.isCalcomOAuthScope = isCalcomOAuthScope;
 exports.logCalcomErrorToConsole = logCalcomErrorToConsole;
 exports.logCalcomOAuthErrorToConsole = logCalcomOAuthErrorToConsole;
 exports.logCalcomServerErrorFunction = logCalcomServerErrorFunction;