@dereekb/zoho 13.32.0 → 13.34.0

package/cli/package.json

@@ -1,17 +1,17 @@
 {
   "name": "@dereekb/zoho/cli",
-  "version": "13.32.0",
+  "version": "13.34.0",
   "type": "module",
   "bin": {
     "zoho-cli": "index.js"
   },
   "peerDependencies": {
-    "@dereekb/dbx-cli": "13.32.0",
-    "@dereekb/nestjs": "13.32.0",
-    "@dereekb/rxjs": "13.32.0",
-    "@dereekb/util": "13.32.0",
-    "@dereekb/zoho": "13.32.0",
-    "@dereekb/zoho/nestjs": "13.32.0",
+    "@dereekb/dbx-cli": "13.34.0",
+    "@dereekb/nestjs": "13.34.0",
+    "@dereekb/rxjs": "13.34.0",
+    "@dereekb/util": "13.34.0",
+    "@dereekb/zoho": "13.34.0",
+    "@dereekb/zoho/nestjs": "13.34.0",
     "yargs": "^18.0.0"
   },
   "devDependencies": {

package/index.cjs.js

@@ -9407,6 +9407,185 @@ function joinAgentInclude(include) {
     return zohoDeskFetchPageFactory(zohoDeskGetAgents(context));
 }
 
+/**
+ * The Zoho Accounts API URL for the US datacenter.
+ */ var ZOHO_ACCOUNTS_US_API_URL = 'https://accounts.zoho.com';
+/**
+ * The Zoho Accounts API URL for the EU datacenter.
+ */ var ZOHO_ACCOUNTS_EU_API_URL = 'https://accounts.zoho.eu';
+/**
+ * The Zoho Accounts API URL for the India datacenter.
+ */ var ZOHO_ACCOUNTS_IN_API_URL = 'https://accounts.zoho.in';
+/**
+ * The Zoho Accounts API URL for the Australia datacenter.
+ */ var ZOHO_ACCOUNTS_AU_API_URL = 'https://accounts.zoho.com.au';
+/**
+ * The Zoho Accounts API URL for the Japan datacenter.
+ */ var ZOHO_ACCOUNTS_JP_API_URL = 'https://accounts.zoho.jp';
+/**
+ * The Zoho Accounts API URL for the United Kingdom datacenter.
+ */ var ZOHO_ACCOUNTS_UK_API_URL = 'https://accounts.zoho.uk';
+/**
+ * The Zoho Accounts API URL for the Canada datacenter.
+ */ var ZOHO_ACCOUNTS_CA_API_URL = 'https://accounts.zohocloud.ca';
+/**
+ * The Zoho Accounts API URL for the Saudi Arabia datacenter.
+ */ var ZOHO_ACCOUNTS_SA_API_URL = 'https://accounts.zoho.sa';
+/**
+ * Every Zoho Accounts host this package will talk to, keyed by datacenter.
+ *
+ * A closed set rather than an open string, because a value echoed back on an OAuth callback
+ * (`accounts-server`) is checked against it before being used as a token-exchange target — an
+ * unchecked host there would receive the client secret.
+ */ var ZOHO_ACCOUNTS_API_URLS = {
+    us: ZOHO_ACCOUNTS_US_API_URL,
+    eu: ZOHO_ACCOUNTS_EU_API_URL,
+    in: ZOHO_ACCOUNTS_IN_API_URL,
+    au: ZOHO_ACCOUNTS_AU_API_URL,
+    jp: ZOHO_ACCOUNTS_JP_API_URL,
+    uk: ZOHO_ACCOUNTS_UK_API_URL,
+    ca: ZOHO_ACCOUNTS_CA_API_URL,
+    sa: ZOHO_ACCOUNTS_SA_API_URL
+};
+/**
+ * Resolves a Zoho Accounts API URL input to the full base URL. A datacenter key maps to that
+ * datacenter's host; custom URLs pass through unchanged.
+ *
+ * @param input - A well-known datacenter key or a custom Zoho Accounts API URL.
+ * @returns The resolved full Zoho Accounts API base URL.
+ */ function zohoAccountsConfigApiUrl(input) {
+    var _ZOHO_ACCOUNTS_API_URLS_input;
+    return (_ZOHO_ACCOUNTS_API_URLS_input = ZOHO_ACCOUNTS_API_URLS[input]) !== null && _ZOHO_ACCOUNTS_API_URLS_input !== void 0 ? _ZOHO_ACCOUNTS_API_URLS_input : input;
+}
+/**
+ * Returns whether the input is one of the known Zoho Accounts hosts.
+ *
+ * Exists to gate a value that arrives from OUTSIDE the process: Zoho echoes the issuing datacenter
+ * back as the `accounts-server` OAuth callback parameter, and that host becomes the POST target the
+ * client secret is sent to. An attacker can compose that redirect, so only an exact match against
+ * {@link ZOHO_ACCOUNTS_API_URLS} may be honored.
+ *
+ * @param url - The candidate accounts host.
+ * @returns True when the value is exactly one of the known Zoho Accounts hosts.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */ function isKnownZohoAccountsApiUrl(url) {
+    return url != null && zohoAccountsApiUrlKeyForApiUrl(url) != null;
+}
+/**
+ * Returns the datacenter key for a known Zoho Accounts host.
+ *
+ * A trailing slash is tolerated, since Zoho's `accounts-server` value is URL-encoded and some
+ * datacenters echo it back with one; nothing else about the value is normalized.
+ *
+ * @param url - The candidate accounts host.
+ * @returns The matching datacenter key, or undefined when the host is not a known one.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */ function zohoAccountsApiUrlKeyForApiUrl(url) {
+    var result;
+    if (url != null) {
+        var normalized = url.replace(/\/+$/, '');
+        result = Object.keys(ZOHO_ACCOUNTS_API_URLS).find(function(key) {
+            return ZOHO_ACCOUNTS_API_URLS[key] === normalized;
+        });
+    }
+    return result;
+}
+
+/**
+ * Path of the Zoho Accounts authorization (consent screen) endpoint.
+ */ var ZOHO_ACCOUNTS_AUTHORIZE_PATH = '/oauth/v2/auth';
+/**
+ * Path of the Zoho Accounts token endpoint.
+ */ var ZOHO_ACCOUNTS_TOKEN_PATH = '/oauth/v2/token';
+/**
+ * The delimiter Zoho joins and returns granted scopes with.
+ *
+ * A comma, NOT the space OAuth 2.0 specifies. Both halves of the round trip use this: the authorize
+ * request joins on it, and the granted `scope` string comes back split on it.
+ */ var ZOHO_OAUTH_SCOPE_DELIMITER = ',';
+/**
+ * The `response_type` used by the authorization-code flow.
+ */ var ZOHO_OAUTH_AUTHORIZE_RESPONSE_TYPE = 'code';
+/**
+ * Required for Zoho to return a `refresh_token` at all.
+ */ var ZOHO_OAUTH_OFFLINE_ACCESS_TYPE = 'offline';
+/**
+ * Forces the consent screen.
+ *
+ * Without it Zoho returns a refresh token only on a user's FIRST authorization, so a reconnect would
+ * come back with an access token alone — and a persisted exchange that omits the refresh token
+ * silently breaks the connection.
+ */ var ZOHO_OAUTH_CONSENT_PROMPT = 'consent';
+/**
+ * Creates a {@link ZohoAccountsAuthorizeUrlFactory} that composes the Zoho authorize URL 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, scopes, and optional datacenter/consent overrides.
+ * @returns A factory that builds an authorize URL for the given params.
+ * @throws {Error} When no client id is given, or when no scopes are requested — Zoho refuses an
+ *   authorize request carrying no scope, and failing at construction beats failing at the consent
+ *   screen.
+ *
+ * @see https://www.zoho.com/accounts/protocol/oauth/web-apps/authorization.html
+ *
+ * @example
+ * ```typescript
+ * const authorizeUrlFactory = zohoAccountsAuthorizeUrlFactory({
+ *   clientId: 'client-id',
+ *   redirectUri: 'http://localhost:9901/oauth/zoho/callback',
+ *   scopes: ['AaaServer.profile.READ']
+ * });
+ *
+ * const url = authorizeUrlFactory({ state: 'signed-state' });
+ * ```
+ *
+ * @__NO_SIDE_EFFECTS__
+ */ function zohoAccountsAuthorizeUrlFactory(config) {
+    var clientId = config.clientId, redirectUri = config.redirectUri, scopes = config.scopes, accountsApiUrl = config.accountsApiUrl, accessType = config.accessType, prompt = config.prompt;
+    if (!clientId) {
+        throw new Error('zohoAccountsAuthorizeUrlFactory() requires a clientId.');
+    }
+    if (!scopes.length) {
+        throw new Error('zohoAccountsAuthorizeUrlFactory() requires at least one scope. Zoho refuses an authorize request that carries no scope.');
+    }
+    var apiUrl = zohoAccountsConfigApiUrl(accountsApiUrl !== null && accountsApiUrl !== void 0 ? accountsApiUrl : 'us');
+    var scope = scopes.join(ZOHO_OAUTH_SCOPE_DELIMITER);
+    var authorizeAccessType = accessType !== null && accessType !== void 0 ? accessType : ZOHO_OAUTH_OFFLINE_ACCESS_TYPE;
+    var authorizePrompt = prompt !== null && prompt !== void 0 ? prompt : ZOHO_OAUTH_CONSENT_PROMPT;
+    return function(params) {
+        var url = new URL(ZOHO_ACCOUNTS_AUTHORIZE_PATH, apiUrl);
+        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', ZOHO_OAUTH_AUTHORIZE_RESPONSE_TYPE);
+        url.searchParams.set('scope', scope);
+        url.searchParams.set('access_type', authorizeAccessType);
+        url.searchParams.set('prompt', authorizePrompt);
+        if (state != null) {
+            url.searchParams.set('state', state);
+        }
+        return url.toString();
+    };
+}
+/**
+ * Splits a granted Zoho `scope` string on the same delimiter the authorize request joins with.
+ *
+ * @param scope - The granted scope string returned on a token response.
+ * @returns The granted scopes, or undefined when none were granted.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */ function zohoOAuthScopesFromScopeString(scope) {
+    var scopes = scope ? scope.split(ZOHO_OAUTH_SCOPE_DELIMITER).filter(function(x) {
+        return x.length > 0;
+    }) : undefined;
+    return (scopes === null || scopes === void 0 ? void 0 : scopes.length) ? scopes : undefined;
+}
+
 /**
  * Creates a function that exchanges a refresh token for a new short-lived access token
  * via the Zoho OAuth `/oauth/v2/token` endpoint.
@@ -9446,7 +9625,47 @@ function joinAgentInclude(include) {
             client_secret: clientSecret,
             refresh_token: refreshToken
         });
-        return context.fetchJson("/oauth/v2/token?".concat(params), zohoAccountsApiFetchJsonInput('POST'));
+        return context.fetchJson("".concat(ZOHO_ACCOUNTS_TOKEN_PATH, "?").concat(params), zohoAccountsApiFetchJsonInput('POST'));
+    };
+}
+/**
+ * Creates a function that exchanges a SPECIFIC USER's refresh token for a new access token.
+ *
+ * The per-user counterpart of {@link zohoAccountsAccessToken}, and narrowed the same way
+ * {@link zohoAccountsRefreshTokenFromAuthorizationCode} is: it takes a
+ * {@link ZohoAccountsOAuthClientContext} rather than a full {@link ZohoAccountsContext}. That matters
+ * because a `ZohoAccountsContext`'s config REQUIRES a `refreshToken` — the app's own — so it cannot
+ * describe a client that refreshes on behalf of many users. A full context stays structurally
+ * assignable, so this is usable from either.
+ *
+ * Zoho does not rotate refresh tokens and its refresh response carries NO `refresh_token`, so the
+ * token passed in here stays valid and must be retained by the caller. The response does carry
+ * `api_domain`, which can differ from the one the grant was created with, so persist it.
+ *
+ * @param context - A Zoho Accounts client context providing fetch and client credentials.
+ * @returns Function that exchanges a user's refresh token for an access token.
+ *
+ * @see https://www.zoho.com/accounts/protocol/oauth/web-apps/access-token-expiry.html
+ *
+ * @example
+ * ```typescript
+ * const userAccessToken = zohoAccountsUserAccessToken(accountsClientContext);
+ * const { access_token, api_domain, expires_in } = await userAccessToken({ refreshToken: user.zohoRefreshToken });
+ * ```
+ */ function zohoAccountsUserAccessToken(context) {
+    return function(input) {
+        var _ref, _ref1;
+        var _context_config = context.config, configClientId = _context_config.clientId, configClientSecret = _context_config.clientSecret;
+        var client = input.client, refreshToken = input.refreshToken;
+        var clientId = (_ref = client === null || client === void 0 ? void 0 : client.clientId) !== null && _ref !== void 0 ? _ref : configClientId;
+        var clientSecret = (_ref1 = client === null || client === void 0 ? void 0 : client.clientSecret) !== null && _ref1 !== void 0 ? _ref1 : configClientSecret;
+        var params = fetch.makeUrlSearchParams({
+            grant_type: 'refresh_token',
+            client_id: clientId,
+            client_secret: clientSecret,
+            refresh_token: refreshToken
+        });
+        return context.fetchJson("".concat(ZOHO_ACCOUNTS_TOKEN_PATH, "?").concat(params), zohoAccountsApiFetchJsonInput('POST'));
     };
 }
 /**
@@ -9490,7 +9709,34 @@ function joinAgentInclude(include) {
             code: code,
             redirect_uri: redirectUri
         });
-        return context.fetchJson("/oauth/v2/token?".concat(params), zohoAccountsApiFetchJsonInput('POST'));
+        return context.fetchJson("".concat(ZOHO_ACCOUNTS_TOKEN_PATH, "?").concat(params), zohoAccountsApiFetchJsonInput('POST'));
+    };
+}
+// MARK: User Info
+/**
+ * Path of the Zoho Accounts endpoint that describes the authorizing user.
+ */ var ZOHO_ACCOUNTS_USER_INFO_PATH = '/oauth/user/info';
+/**
+ * Scope required to read {@link zohoAccountsUserInfo}.
+ */ var ZOHO_ACCOUNTS_PROFILE_READ_SCOPE = 'AaaServer.profile.READ';
+/**
+ * Creates a function that reads the authorizing user's Zoho identity, so a connection can be
+ * labelled with the account it belongs to.
+ *
+ * Requires the {@link ZOHO_ACCOUNTS_PROFILE_READ_SCOPE} scope on the access token.
+ *
+ * @param context - Zoho Accounts OAuth client context providing fetch.
+ * @returns Function that reads the user info for an access token.
+ *
+ * @see https://www.zoho.com/accounts/protocol/oauth/web-apps/get-user-info.html
+ */ function zohoAccountsUserInfo(context) {
+    return function(input) {
+        return context.fetchJson(ZOHO_ACCOUNTS_USER_INFO_PATH, {
+            method: 'GET',
+            headers: {
+                Authorization: "Zoho-oauthtoken ".concat(input.accessToken)
+            }
+        });
     };
 }
 /**
@@ -9506,27 +9752,6 @@ function joinAgentInclude(include) {
     };
 }
 
-/**
- * The Zoho Accounts API URL for the US datacenter.
- */ var ZOHO_ACCOUNTS_US_API_URL = 'https://accounts.zoho.com';
-/**
- * Resolves a Zoho Accounts API URL input to the full base URL. The 'us' key maps to the US datacenter; custom URLs pass through unchanged.
- *
- * @param input - A well-known datacenter key or a custom Zoho Accounts API URL.
- * @returns The resolved full Zoho Accounts API base URL.
- */ function zohoAccountsConfigApiUrl(input) {
-    var result;
-    switch(input){
-        case 'us':
-            result = ZOHO_ACCOUNTS_US_API_URL;
-            break;
-        default:
-            result = input;
-            break;
-    }
-    return result;
-}
-
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
     try {
         var info = gen[key](arg);
@@ -9702,6 +9927,50 @@ function _ts_generator(thisArg, body) {
         };
     }
 }
+/**
+ * Creates the {@link ZohoAccountsFetchFactory} the Zoho Accounts clients use when none is supplied.
+ *
+ * @param fetchHandler - The handler the produced fetches route through.
+ * @returns The default Zoho Accounts fetch factory.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */ function defaultZohoAccountsFetchFactory(fetchHandler) {
+    return function(input) {
+        return fetch.fetchApiFetchService.makeFetch({
+            baseUrl: input.apiUrl,
+            baseRequest: {
+                headers: {
+                    'Content-Type': 'application/json'
+                }
+            },
+            fetchHandler: fetchHandler,
+            timeout: 20 * 1000,
+            requireOkResponse: true,
+            useTimeout: true // use timeout
+        });
+    };
+}
+/**
+ * Builds the error-handling fetch pair shared by the full and client-credentials-only clients.
+ *
+ * Shared rather than duplicated because {@link interceptZohoAccounts200StatusWithErrorResponse} is
+ * load-bearing: Zoho answers a failed token exchange with HTTP 200 and an `{ "error": … }` body, so
+ * a hand-rolled fetch would treat a failed exchange as a success with an undefined access token.
+ *
+ * @param baseFetch - The configured base fetch to wrap.
+ * @param logZohoServerErrorFunction - Optional error logging override.
+ * @returns The wrapped fetch and its JSON counterpart.
+ */ function zohoAccountsClientFetch(baseFetch, logZohoServerErrorFunction) {
+    var fetch$1 = handleZohoAccountsErrorFetch(baseFetch, logZohoServerErrorFunction);
+    var fetchJson = fetch.fetchJsonFunction(fetch$1, {
+        interceptJsonResponse: interceptZohoAccounts200StatusWithErrorResponse,
+        handleFetchJsonParseErrorFunction: fetch.returnNullHandleFetchJsonParseErrorFunction
+    });
+    return {
+        fetch: fetch$1,
+        fetchJson: fetchJson
+    };
+}
 /**
  * Creates a {@link ZohoAccountsFactory} from the given configuration.
  *
@@ -9737,20 +10006,7 @@ function _ts_generator(thisArg, body) {
  * @__NO_SIDE_EFFECTS__
  */ function zohoAccountsFactory(factoryConfig) {
     var fetchHandler = zohoRateLimitedFetchHandler();
-    var logZohoServerErrorFunction = factoryConfig.logZohoServerErrorFunction, _factoryConfig_fetchFactory = factoryConfig.fetchFactory, fetchFactory = _factoryConfig_fetchFactory === void 0 ? function(input) {
-        return fetch.fetchApiFetchService.makeFetch({
-            baseUrl: input.apiUrl,
-            baseRequest: {
-                headers: {
-                    'Content-Type': 'application/json'
-                }
-            },
-            fetchHandler: fetchHandler,
-            timeout: 20 * 1000,
-            requireOkResponse: true,
-            useTimeout: true // use timeout
-        });
-    } : _factoryConfig_fetchFactory;
+    var logZohoServerErrorFunction = factoryConfig.logZohoServerErrorFunction, _factoryConfig_fetchFactory = factoryConfig.fetchFactory, fetchFactory = _factoryConfig_fetchFactory === void 0 ? defaultZohoAccountsFetchFactory(fetchHandler) : _factoryConfig_fetchFactory;
     return function(config) {
         var _config_apiUrl;
         if (!config.refreshToken) {
@@ -9764,11 +10020,7 @@ function _ts_generator(thisArg, body) {
         var baseFetch = fetchFactory({
             apiUrl: apiUrl
         });
-        var fetch$1 = handleZohoAccountsErrorFetch(baseFetch, logZohoServerErrorFunction);
-        var fetchJson = fetch.fetchJsonFunction(fetch$1, {
-            interceptJsonResponse: interceptZohoAccounts200StatusWithErrorResponse,
-            handleFetchJsonParseErrorFunction: fetch.returnNullHandleFetchJsonParseErrorFunction
-        });
+        var _zohoAccountsClientFetch = zohoAccountsClientFetch(baseFetch, logZohoServerErrorFunction), fetch = _zohoAccountsClientFetch.fetch, fetchJson = _zohoAccountsClientFetch.fetchJson;
         var tokenRefresher = function tokenRefresher() {
             return _async_to_generator(function() {
                 var createdAt, _ref, access_token, api_domain, scope, expires_in, result;
@@ -9813,7 +10065,7 @@ function _ts_generator(thisArg, body) {
             accessTokenCache: config.accessTokenCache
         });
         var accountsContext = {
-            fetch: fetch$1,
+            fetch: fetch,
             fetchJson: fetchJson,
             loadAccessToken: loadAccessToken,
             config: _object_spread_props(_object_spread({}, config), {
@@ -9826,6 +10078,52 @@ function _ts_generator(thisArg, body) {
         return zohoAccounts;
     };
 }
+/**
+ * Creates a {@link ZohoAccountsOAuthClientFactory}, producing Zoho Accounts clients authenticated by
+ * CLIENT CREDENTIALS ALONE.
+ *
+ * {@link zohoAccountsFactory} requires a refresh token, which a per-user authorization-code handoff
+ * does not have yet — the handoff is how the refresh token is obtained. This client covers exactly
+ * the two endpoints that need no user token: the authorization-code exchange and
+ * `/oauth/user/info`.
+ *
+ * It builds its fetch through the same error handling as the full client, which matters more than it
+ * looks: Zoho answers a failed token exchange with HTTP 200 and an `{ "error": … }` body, and
+ * `interceptZohoAccounts200StatusWithErrorResponse` is what turns that into a thrown error instead
+ * of a "successful" exchange with an undefined access token.
+ *
+ * @param factoryConfig - Configuration providing optional fetch and logging overrides.
+ * @returns A factory function that creates client-credentials-only Zoho Accounts clients.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */ function zohoAccountsOAuthClientFactory(factoryConfig) {
+    var _factoryConfig_fetchHandler;
+    var fetchHandler = (_factoryConfig_fetchHandler = factoryConfig.fetchHandler) !== null && _factoryConfig_fetchHandler !== void 0 ? _factoryConfig_fetchHandler : zohoRateLimitedFetchHandler();
+    var logZohoServerErrorFunction = factoryConfig.logZohoServerErrorFunction, _factoryConfig_fetchFactory = factoryConfig.fetchFactory, fetchFactory = _factoryConfig_fetchFactory === void 0 ? defaultZohoAccountsFetchFactory(fetchHandler) : _factoryConfig_fetchFactory;
+    return function(config) {
+        var _config_apiUrl;
+        if (!config.clientId) {
+            throw new Error('ZohoAccountsOAuthClientConfig missing clientId.');
+        } else if (!config.clientSecret) {
+            throw new Error('ZohoAccountsOAuthClientConfig missing clientSecret.');
+        }
+        var apiUrl = zohoAccountsConfigApiUrl((_config_apiUrl = config.apiUrl) !== null && _config_apiUrl !== void 0 ? _config_apiUrl : 'us');
+        var baseFetch = fetchFactory({
+            apiUrl: apiUrl
+        });
+        var fetchJson = zohoAccountsClientFetch(baseFetch, logZohoServerErrorFunction).fetchJson;
+        var resolvedConfig = _object_spread_props(_object_spread({}, config), {
+            apiUrl: apiUrl
+        });
+        var oauthClientContext = {
+            fetchJson: fetchJson,
+            config: resolvedConfig
+        };
+        return {
+            oauthClientContext: oauthClientContext
+        };
+    };
+}
 /**
  * Creates a {@link ZohoAccessTokenFactory} that manages access token lifecycle with
  * in-memory caching, optional external cache support, and automatic refresh.
@@ -9977,8 +10275,20 @@ exports.DEFAULT_ZOHO_RATE_LIMITED_TOO_MANY_REQUESTS_LOG_FUNCTION = DEFAULT_ZOHO_
 exports.DEFAULT_ZOHO_RATE_LIMITED_TOO_MANY_REQUETS_LOG_FUNCTION = DEFAULT_ZOHO_RATE_LIMITED_TOO_MANY_REQUETS_LOG_FUNCTION;
 exports.MAX_ZOHO_CRM_SEARCH_MODULE_RECORDS_CRITERIA = MAX_ZOHO_CRM_SEARCH_MODULE_RECORDS_CRITERIA;
 exports.MAX_ZOHO_RECRUIT_SEARCH_MODULE_RECORDS_CRITERIA = MAX_ZOHO_RECRUIT_SEARCH_MODULE_RECORDS_CRITERIA;
+exports.ZOHO_ACCOUNTS_API_URLS = ZOHO_ACCOUNTS_API_URLS;
+exports.ZOHO_ACCOUNTS_AUTHORIZE_PATH = ZOHO_ACCOUNTS_AUTHORIZE_PATH;
+exports.ZOHO_ACCOUNTS_AU_API_URL = ZOHO_ACCOUNTS_AU_API_URL;
+exports.ZOHO_ACCOUNTS_CA_API_URL = ZOHO_ACCOUNTS_CA_API_URL;
+exports.ZOHO_ACCOUNTS_EU_API_URL = ZOHO_ACCOUNTS_EU_API_URL;
 exports.ZOHO_ACCOUNTS_INVALID_CLIENT_ERROR_CODE = ZOHO_ACCOUNTS_INVALID_CLIENT_ERROR_CODE;
 exports.ZOHO_ACCOUNTS_INVALID_CODE_ERROR_CODE = ZOHO_ACCOUNTS_INVALID_CODE_ERROR_CODE;
+exports.ZOHO_ACCOUNTS_IN_API_URL = ZOHO_ACCOUNTS_IN_API_URL;
+exports.ZOHO_ACCOUNTS_JP_API_URL = ZOHO_ACCOUNTS_JP_API_URL;
+exports.ZOHO_ACCOUNTS_PROFILE_READ_SCOPE = ZOHO_ACCOUNTS_PROFILE_READ_SCOPE;
+exports.ZOHO_ACCOUNTS_SA_API_URL = ZOHO_ACCOUNTS_SA_API_URL;
+exports.ZOHO_ACCOUNTS_TOKEN_PATH = ZOHO_ACCOUNTS_TOKEN_PATH;
+exports.ZOHO_ACCOUNTS_UK_API_URL = ZOHO_ACCOUNTS_UK_API_URL;
+exports.ZOHO_ACCOUNTS_USER_INFO_PATH = ZOHO_ACCOUNTS_USER_INFO_PATH;
 exports.ZOHO_ACCOUNTS_US_API_URL = ZOHO_ACCOUNTS_US_API_URL;
 exports.ZOHO_CRM_ADD_TAGS_TO_RECORDS_MAX_IDS_ALLOWED = ZOHO_CRM_ADD_TAGS_TO_RECORDS_MAX_IDS_ALLOWED;
 exports.ZOHO_CRM_ALREADY_ASSOCIATED_ERROR_CODE = ZOHO_CRM_ALREADY_ASSOCIATED_ERROR_CODE;
@@ -10009,6 +10319,10 @@ exports.ZOHO_INVALID_DATA_ERROR_CODE = ZOHO_INVALID_DATA_ERROR_CODE;
 exports.ZOHO_INVALID_QUERY_ERROR_CODE = ZOHO_INVALID_QUERY_ERROR_CODE;
 exports.ZOHO_INVALID_TOKEN_ERROR_CODE = ZOHO_INVALID_TOKEN_ERROR_CODE;
 exports.ZOHO_MANDATORY_NOT_FOUND_ERROR_CODE = ZOHO_MANDATORY_NOT_FOUND_ERROR_CODE;
+exports.ZOHO_OAUTH_AUTHORIZE_RESPONSE_TYPE = ZOHO_OAUTH_AUTHORIZE_RESPONSE_TYPE;
+exports.ZOHO_OAUTH_CONSENT_PROMPT = ZOHO_OAUTH_CONSENT_PROMPT;
+exports.ZOHO_OAUTH_OFFLINE_ACCESS_TYPE = ZOHO_OAUTH_OFFLINE_ACCESS_TYPE;
+exports.ZOHO_OAUTH_SCOPE_DELIMITER = ZOHO_OAUTH_SCOPE_DELIMITER;
 exports.ZOHO_RATE_LIMIT_LIMIT_HEADER = ZOHO_RATE_LIMIT_LIMIT_HEADER;
 exports.ZOHO_RATE_LIMIT_REMAINING_HEADER = ZOHO_RATE_LIMIT_REMAINING_HEADER;
 exports.ZOHO_RATE_LIMIT_RESET_HEADER = ZOHO_RATE_LIMIT_RESET_HEADER;
@@ -10063,6 +10377,7 @@ exports.assertZohoRecruitRecordDataArrayResultHasContent = assertZohoRecruitReco
 exports.createNotes = createNotes;
 exports.createNotesForRecord = createNotesForRecord;
 exports.createTagsForModule = createTagsForModule;
+exports.defaultZohoAccountsFetchFactory = defaultZohoAccountsFetchFactory;
 exports.deleteAttachmentFromRecord = deleteAttachmentFromRecord;
 exports.deleteNotes = deleteNotes;
 exports.deleteRecord = deleteRecord;
@@ -10094,6 +10409,7 @@ exports.interceptZohoDesk200StatusWithErrorResponse = interceptZohoDesk200Status
 exports.interceptZohoErrorResponseFactory = interceptZohoErrorResponseFactory;
 exports.interceptZohoRecruit200StatusWithErrorResponse = interceptZohoRecruit200StatusWithErrorResponse;
 exports.interceptZohoSign200StatusWithErrorResponse = interceptZohoSign200StatusWithErrorResponse;
+exports.isKnownZohoAccountsApiUrl = isKnownZohoAccountsApiUrl;
 exports.isZohoCrmValidUrl = isZohoCrmValidUrl;
 exports.isZohoRecruitValidUrl = isZohoRecruitValidUrl;
 exports.isZohoServerErrorResponseDataArrayRef = isZohoServerErrorResponseDataArrayRef;
@@ -10126,9 +10442,14 @@ exports.upsertRecord = upsertRecord;
 exports.zohoAccessTokenStringFactory = zohoAccessTokenStringFactory;
 exports.zohoAccountsAccessToken = zohoAccountsAccessToken;
 exports.zohoAccountsApiFetchJsonInput = zohoAccountsApiFetchJsonInput;
+exports.zohoAccountsApiUrlKeyForApiUrl = zohoAccountsApiUrlKeyForApiUrl;
+exports.zohoAccountsAuthorizeUrlFactory = zohoAccountsAuthorizeUrlFactory;
 exports.zohoAccountsConfigApiUrl = zohoAccountsConfigApiUrl;
 exports.zohoAccountsFactory = zohoAccountsFactory;
+exports.zohoAccountsOAuthClientFactory = zohoAccountsOAuthClientFactory;
 exports.zohoAccountsRefreshTokenFromAuthorizationCode = zohoAccountsRefreshTokenFromAuthorizationCode;
+exports.zohoAccountsUserAccessToken = zohoAccountsUserAccessToken;
+exports.zohoAccountsUserInfo = zohoAccountsUserInfo;
 exports.zohoAccountsZohoAccessTokenFactory = zohoAccountsZohoAccessTokenFactory;
 exports.zohoCrmAddTagsToRecords = zohoCrmAddTagsToRecords;
 exports.zohoCrmAddTagsToRecordsRequestBody = zohoCrmAddTagsToRecordsRequestBody;
@@ -10224,6 +10545,7 @@ exports.zohoDeskSearchTags = zohoDeskSearchTags;
 exports.zohoDeskSearchTickets = zohoDeskSearchTickets;
 exports.zohoDeskSearchTicketsPageFactory = zohoDeskSearchTicketsPageFactory;
 exports.zohoFetchPageFactory = zohoFetchPageFactory;
+exports.zohoOAuthScopesFromScopeString = zohoOAuthScopesFromScopeString;
 exports.zohoRateLimitHeaderDetails = zohoRateLimitHeaderDetails;
 exports.zohoRateLimitedFetchHandler = zohoRateLimitedFetchHandler;
 exports.zohoRecruitAddTagsToRecords = zohoRecruitAddTagsToRecords;