@dereekb/zoho 13.31.0 → 13.33.0

package/nestjs/index.cjs.js

@@ -81,12 +81,12 @@ function readZohoConfigFromConfigService(configOrService, servicePrefix) {
     }
 }
 
-function _class_call_check$e(instance, Constructor) {
+function _class_call_check$g(instance, Constructor) {
     if (!(instance instanceof Constructor)) {
         throw new TypeError("Cannot call a class as a function");
     }
 }
-function _defineProperties$c(target, props) {
+function _defineProperties$e(target, props) {
     for(var i = 0; i < props.length; i++){
         var descriptor = props[i];
         descriptor.enumerable = descriptor.enumerable || false;
@@ -95,11 +95,11 @@ function _defineProperties$c(target, props) {
         Object.defineProperty(target, descriptor.key, descriptor);
     }
 }
-function _create_class$c(Constructor, protoProps, staticProps) {
-    if (staticProps) _defineProperties$c(Constructor, staticProps);
+function _create_class$e(Constructor, protoProps, staticProps) {
+    if (staticProps) _defineProperties$e(Constructor, staticProps);
     return Constructor;
 }
-function _define_property$e(obj, key, value) {
+function _define_property$g(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -116,11 +116,11 @@ function _define_property$e(obj, key, value) {
  * Configuration for ZohoService
  */ var ZohoAccountsServiceConfig = /*#__PURE__*/ function() {
     function ZohoAccountsServiceConfig() {
-        _class_call_check$e(this, ZohoAccountsServiceConfig);
-        _define_property$e(this, "zohoAccounts", void 0);
-        _define_property$e(this, "factoryConfig", void 0);
+        _class_call_check$g(this, ZohoAccountsServiceConfig);
+        _define_property$g(this, "zohoAccounts", void 0);
+        _define_property$g(this, "factoryConfig", void 0);
     }
-    _create_class$c(ZohoAccountsServiceConfig, null, [
+    _create_class$e(ZohoAccountsServiceConfig, null, [
         {
             key: "assertValidConfig",
             value: function assertValidConfig(config) {
@@ -184,7 +184,7 @@ function _define_property$e(obj, key, value) {
     return config;
 }
 
-function _array_like_to_array$4(arr, len) {
+function _array_like_to_array$5(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
     for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
     return arr2;
@@ -192,8 +192,8 @@ function _array_like_to_array$4(arr, len) {
 function _array_with_holes(arr) {
     if (Array.isArray(arr)) return arr;
 }
-function _array_without_holes$4(arr) {
-    if (Array.isArray(arr)) return _array_like_to_array$4(arr);
+function _array_without_holes$5(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$5(arr);
 }
 function asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, key, arg) {
     try {
@@ -224,12 +224,12 @@ function _async_to_generator$3(fn) {
         });
     };
 }
-function _class_call_check$d(instance, Constructor) {
+function _class_call_check$f(instance, Constructor) {
     if (!(instance instanceof Constructor)) {
         throw new TypeError("Cannot call a class as a function");
     }
 }
-function _define_property$d(obj, key, value) {
+function _define_property$f(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -250,7 +250,7 @@ function _instanceof(left, right) {
         return left instanceof right;
     }
 }
-function _iterable_to_array$4(iter) {
+function _iterable_to_array$5(iter) {
     if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
 }
 function _iterable_to_array_limit(arr, i) {
@@ -280,7 +280,7 @@ function _iterable_to_array_limit(arr, i) {
 function _non_iterable_rest() {
     throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
-function _non_iterable_spread$4() {
+function _non_iterable_spread$5() {
     throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
 function _object_spread$6(target) {
@@ -293,7 +293,7 @@ function _object_spread$6(target) {
             }));
         }
         ownKeys.forEach(function(key) {
-            _define_property$d(target, key, source[key]);
+            _define_property$f(target, key, source[key]);
         });
     }
     return target;
@@ -318,22 +318,22 @@ function _object_spread_props$5(target, source) {
     return target;
 }
 function _sliced_to_array(arr, i) {
-    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array$4(arr, i) || _non_iterable_rest();
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array$5(arr, i) || _non_iterable_rest();
 }
-function _to_consumable_array$4(arr) {
-    return _array_without_holes$4(arr) || _iterable_to_array$4(arr) || _unsupported_iterable_to_array$4(arr) || _non_iterable_spread$4();
+function _to_consumable_array$5(arr) {
+    return _array_without_holes$5(arr) || _iterable_to_array$5(arr) || _unsupported_iterable_to_array$5(arr) || _non_iterable_spread$5();
 }
 function _type_of(obj) {
     "@swc/helpers - typeof";
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 }
-function _unsupported_iterable_to_array$4(o, minLen) {
+function _unsupported_iterable_to_array$5(o, minLen) {
     if (!o) return;
-    if (typeof o === "string") return _array_like_to_array$4(o, minLen);
+    if (typeof o === "string") return _array_like_to_array$5(o, minLen);
     var n = Object.prototype.toString.call(o).slice(8, -1);
     if (n === "Object" && o.constructor) n = o.constructor.name;
     if (n === "Map" || n === "Set") return Array.from(n);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$4(o, minLen);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$5(o, minLen);
 }
 function _ts_generator$3(thisArg, body) {
     var f, y, t, _ = {
@@ -437,7 +437,7 @@ function _ts_generator$3(thisArg, body) {
 /**
  * Service used for retrieving ZohoAccessTokenCache for Zoho services.
  */ exports.ZohoAccountsAccessTokenCacheService = function ZohoAccountsAccessTokenCacheService() {
-    _class_call_check$d(this, ZohoAccountsAccessTokenCacheService);
+    _class_call_check$f(this, ZohoAccountsAccessTokenCacheService);
 };
 exports.ZohoAccountsAccessTokenCacheService = __decorate([
     common.Injectable()
@@ -512,7 +512,7 @@ function updateZohoCacheCapturingError(cache, accessToken) {
  * @returns A merged ZohoAccountsAccessTokenCacheService that delegates across all inputs.
  * @throws {Error} When `inputServicesToMerge` is empty.
  */ function mergeZohoAccountsAccessTokenCacheServices(inputServicesToMerge, logError) {
-    var services = _to_consumable_array$4(inputServicesToMerge);
+    var services = _to_consumable_array$5(inputServicesToMerge);
     var logErrorFunction = typeof logError === 'function' ? logError : logError === false ? undefined : logMergeZohoAccountsAccessTokenCacheServiceErrorFunction;
     if (services.length === 0) {
         throw new Error('mergeZohoAccountsAccessTokenCacheServices() input cannot be empty.');
@@ -980,12 +980,12 @@ var DEFAULT_FILE_ZOHO_ACCOUNTS_ACCESS_TOKEN_CACHE_SERVICE_PATH = '.tmp/zoho-acce
     };
 }
 
-function _class_call_check$c(instance, Constructor) {
+function _class_call_check$e(instance, Constructor) {
     if (!(instance instanceof Constructor)) {
         throw new TypeError("Cannot call a class as a function");
     }
 }
-function _defineProperties$b(target, props) {
+function _defineProperties$d(target, props) {
     for(var i = 0; i < props.length; i++){
         var descriptor = props[i];
         descriptor.enumerable = descriptor.enumerable || false;
@@ -994,11 +994,11 @@ function _defineProperties$b(target, props) {
         Object.defineProperty(target, descriptor.key, descriptor);
     }
 }
-function _create_class$b(Constructor, protoProps, staticProps) {
-    if (protoProps) _defineProperties$b(Constructor.prototype, protoProps);
+function _create_class$d(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$d(Constructor.prototype, protoProps);
     return Constructor;
 }
-function _define_property$c(obj, key, value) {
+function _define_property$e(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -1021,18 +1021,18 @@ function _object_spread$5(target) {
             }));
         }
         ownKeys.forEach(function(key) {
-            _define_property$c(target, key, source[key]);
+            _define_property$e(target, key, source[key]);
         });
     }
     return target;
 }
 exports.ZohoAccountsApi = /*#__PURE__*/ function() {
     function ZohoAccountsApi(config, cacheService) {
-        _class_call_check$c(this, ZohoAccountsApi);
+        _class_call_check$e(this, ZohoAccountsApi);
         var _config_zohoAccounts_accessTokenCache, _config_factoryConfig;
-        _define_property$c(this, "config", void 0);
-        _define_property$c(this, "cacheService", void 0);
-        _define_property$c(this, "zohoAccounts", void 0);
+        _define_property$e(this, "config", void 0);
+        _define_property$e(this, "cacheService", void 0);
+        _define_property$e(this, "zohoAccounts", void 0);
         this.config = config;
         this.cacheService = cacheService;
         var accessTokenCache = (_config_zohoAccounts_accessTokenCache = config.zohoAccounts.accessTokenCache) !== null && _config_zohoAccounts_accessTokenCache !== void 0 ? _config_zohoAccounts_accessTokenCache : cacheService.loadZohoAccessTokenCache(config.zohoAccounts.serviceAccessTokenKey);
@@ -1040,7 +1040,7 @@ exports.ZohoAccountsApi = /*#__PURE__*/ function() {
             accessTokenCache: accessTokenCache
         }, config.zohoAccounts));
     }
-    _create_class$b(ZohoAccountsApi, [
+    _create_class$d(ZohoAccountsApi, [
         {
             key: "accountsContext",
             get: function get() {
@@ -1063,6 +1063,314 @@ exports.ZohoAccountsApi = __decorate([
     __param(1, common.Inject(exports.ZohoAccountsAccessTokenCacheService))
 ], exports.ZohoAccountsApi);
 
+function _class_call_check$d(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties$c(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class$c(Constructor, protoProps, staticProps) {
+    if (staticProps) _defineProperties$c(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property$d(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+/**
+ * Environment key naming the Zoho Accounts datacenter (or a full accounts URL) to authorize against.
+ */ var ZOHO_ACCOUNTS_URL_CONFIG_KEY = 'ZOHO_ACCOUNTS_URL';
+/**
+ * Environment key holding the Zoho OAuth client id.
+ */ var ZOHO_ACCOUNTS_CLIENT_ID_CONFIG_KEY = 'ZOHO_ACCOUNTS_CLIENT_ID';
+/**
+ * Environment key holding the Zoho OAuth client secret.
+ */ var ZOHO_ACCOUNTS_CLIENT_SECRET_CONFIG_KEY = 'ZOHO_ACCOUNTS_CLIENT_SECRET';
+/**
+ * Configuration for {@link ZohoAccountsOAuthApi}.
+ *
+ * Read from the three existing flat `ZOHO_ACCOUNTS_*` keys rather than composed through
+ * `zohoConfigServiceReaderFunction`, which requires a `serviceAccessTokenKey` a per-user OAuth
+ * client does not have. Notably absent: `ZOHO_ACCOUNTS_REFRESH_TOKEN` (a per-user flow has no
+ * server refresh token) and any scope variable (scopes are declared in code).
+ */ var ZohoAccountsOAuthServiceConfig = /*#__PURE__*/ function() {
+    function ZohoAccountsOAuthServiceConfig() {
+        _class_call_check$d(this, ZohoAccountsOAuthServiceConfig);
+        _define_property$d(this, "zohoAccountsOAuth", void 0);
+        _define_property$d(this, "factoryConfig", void 0);
+    }
+    _create_class$c(ZohoAccountsOAuthServiceConfig, null, [
+        {
+            key: "assertValidConfig",
+            value: function assertValidConfig(config) {
+                var zohoAccountsOAuth = config.zohoAccountsOAuth;
+                if (!zohoAccountsOAuth) {
+                    throw new Error('ZohoAccountsOAuthServiceConfig.zohoAccountsOAuth is required');
+                }
+                if (!zohoAccountsOAuth.clientId) {
+                    throw new Error("ZohoAccountsOAuthServiceConfig requires a clientId (".concat(ZOHO_ACCOUNTS_CLIENT_ID_CONFIG_KEY, ")."));
+                }
+                if (!zohoAccountsOAuth.clientSecret) {
+                    throw new Error("ZohoAccountsOAuthServiceConfig requires a clientSecret (".concat(ZOHO_ACCOUNTS_CLIENT_SECRET_CONFIG_KEY, ")."));
+                }
+            }
+        }
+    ]);
+    return ZohoAccountsOAuthServiceConfig;
+}();
+/**
+ * Factory function that creates a {@link ZohoAccountsOAuthServiceConfig} from NestJS ConfigService
+ * environment variables.
+ *
+ * @param configService - The NestJS ConfigService instance.
+ * @returns A validated ZohoAccountsOAuthServiceConfig.
+ * @throws {Error} When the client id or client secret is not configured.
+ */ function zohoAccountsOAuthServiceConfigFactory(configService) {
+    var clientId = configService.get(ZOHO_ACCOUNTS_CLIENT_ID_CONFIG_KEY);
+    var clientSecret = configService.get(ZOHO_ACCOUNTS_CLIENT_SECRET_CONFIG_KEY);
+    var apiUrl = configService.get(ZOHO_ACCOUNTS_URL_CONFIG_KEY);
+    var config = {
+        zohoAccountsOAuth: {
+            clientId: clientId || undefined,
+            clientSecret: clientSecret || undefined,
+            apiUrl: apiUrl || undefined
+        }
+    };
+    ZohoAccountsOAuthServiceConfig.assertValidConfig(config);
+    return config;
+}
+
+function _class_call_check$c(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties$b(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class$b(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$b(Constructor.prototype, protoProps);
+    return Constructor;
+}
+function _define_property$c(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+/**
+ * The Zoho Accounts endpoints a per-user connect flow needs: the authorization-code exchange, the
+ * per-user token refresh, and the identity lookup that labels the connection.
+ *
+ * Deliberately separate from {@link ZohoAccountsApi}, which requires a server refresh token and a
+ * token cache. A per-user handoff has neither — the handoff is how a refresh token is obtained.
+ */ exports.ZohoAccountsOAuthApi = /*#__PURE__*/ function() {
+    function ZohoAccountsOAuthApi(config) {
+        _class_call_check$c(this, ZohoAccountsOAuthApi);
+        var _config_factoryConfig;
+        _define_property$c(this, "config", void 0);
+        _define_property$c(this, "_clientFactory", void 0);
+        /**
+     * Per-host clients, memoized so a repeated datacenter reuses one client rather than rebuilding
+     * its fetch stack per callback.
+     */ _define_property$c(this, "_clients", new Map());
+        /**
+     * The accounts host configured for this app.
+     */ _define_property$c(this, "apiUrl", void 0);
+        /**
+     * The OAuth client id the authorize request is composed with.
+     */ _define_property$c(this, "clientId", void 0);
+        _define_property$c(this, "_clientSecret", void 0);
+        this.config = config;
+        // asserted here rather than trusted, so a config assembled in code (not through the env factory,
+        // which already asserts) cannot reach the consent screen with an undefined client id
+        ZohoAccountsOAuthServiceConfig.assertValidConfig(config);
+        var _config_zohoAccountsOAuth = config.zohoAccountsOAuth, apiUrl = _config_zohoAccountsOAuth.apiUrl, clientId = _config_zohoAccountsOAuth.clientId, clientSecret = _config_zohoAccountsOAuth.clientSecret;
+        this.apiUrl = zoho.zohoAccountsConfigApiUrl(apiUrl !== null && apiUrl !== void 0 ? apiUrl : 'us');
+        this.clientId = clientId;
+        this._clientSecret = clientSecret;
+        this._clientFactory = zoho.zohoAccountsOAuthClientFactory((_config_factoryConfig = config.factoryConfig) !== null && _config_factoryConfig !== void 0 ? _config_factoryConfig : {});
+    }
+    _create_class$b(ZohoAccountsOAuthApi, [
+        {
+            key: "oauthClientContext",
+            get: /**
+     * The client for the configured datacenter.
+     */ function get() {
+                return this.oauthClientContextForApiUrl(this.apiUrl);
+            }
+        },
+        {
+            /**
+     * The client for a specific accounts host, memoized per host.
+     *
+     * Zoho echoes the issuing datacenter back as `accounts-server` on the callback, and a code issued
+     * by one datacenter cannot be exchanged at another. Callers MUST have checked the host against
+     * `isKnownZohoAccountsApiUrl` first — this method will happily build a client for any URL, and the
+     * client secret travels to whatever host it is given.
+     *
+     * @param apiUrl - The datacenter key or full accounts URL to build a client for.
+     * @returns The memoized client context for that host.
+     */ key: "oauthClientContextForApiUrl",
+            value: function oauthClientContextForApiUrl(apiUrl) {
+                var resolvedApiUrl = zoho.zohoAccountsConfigApiUrl(apiUrl);
+                var context = this._clients.get(resolvedApiUrl);
+                if (context == null) {
+                    context = this._clientFactory({
+                        clientId: this.clientId,
+                        clientSecret: this._clientSecret,
+                        apiUrl: resolvedApiUrl
+                    }).oauthClientContext;
+                    this._clients.set(resolvedApiUrl, context);
+                }
+                return context;
+            }
+        },
+        {
+            // MARK: Accessors
+            /**
+     * Exchanges a single-use authorization code for tokens.
+     *
+     * @param input - The code, the redirect URI it was issued against, and the optional accounts host.
+     * @returns The Zoho token response. `refresh_token` may be absent on a re-consent.
+     */ key: "exchangeAuthorizationCode",
+            value: function exchangeAuthorizationCode(input) {
+                var code = input.code, redirectUri = input.redirectUri, accountsApiUrl = input.accountsApiUrl;
+                var context = this.oauthClientContextForApiUrl(accountsApiUrl !== null && accountsApiUrl !== void 0 ? accountsApiUrl : this.apiUrl);
+                return zoho.zohoAccountsRefreshTokenFromAuthorizationCode(context)({
+                    code: code,
+                    redirectUri: redirectUri
+                });
+            }
+        },
+        {
+            /**
+     * Exchanges a user's refresh token for a new access token.
+     *
+     * Zoho does not rotate refresh tokens, so the token passed in stays valid and the response carries
+     * no replacement — the caller keeps the one it already has. The response DOES carry `api_domain`,
+     * which is the host the new access token is usable against, so persist it.
+     *
+     * @param input - The user's refresh token and the optional accounts host.
+     * @returns The Zoho access token response.
+     */ key: "refreshUserAccessToken",
+            value: function refreshUserAccessToken(input) {
+                var refreshToken = input.refreshToken, accountsApiUrl = input.accountsApiUrl;
+                var context = this.oauthClientContextForApiUrl(accountsApiUrl !== null && accountsApiUrl !== void 0 ? accountsApiUrl : this.apiUrl);
+                return zoho.zohoAccountsUserAccessToken(context)({
+                    refreshToken: refreshToken
+                });
+            }
+        },
+        {
+            /**
+     * Reads the Zoho identity an access token was issued to.
+     *
+     * @param input - The access token and the optional accounts host.
+     * @returns The user info response.
+     */ key: "userInfo",
+            value: function userInfo(input) {
+                var accessToken = input.accessToken, accountsApiUrl = input.accountsApiUrl;
+                var context = this.oauthClientContextForApiUrl(accountsApiUrl !== null && accountsApiUrl !== void 0 ? accountsApiUrl : this.apiUrl);
+                return zoho.zohoAccountsUserInfo(context)({
+                    accessToken: accessToken
+                });
+            }
+        }
+    ]);
+    return ZohoAccountsOAuthApi;
+}();
+exports.ZohoAccountsOAuthApi = __decorate([
+    common.Injectable(),
+    __param(0, common.Inject(ZohoAccountsOAuthServiceConfig))
+], exports.ZohoAccountsOAuthApi);
+
+function _array_like_to_array$4(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes$4(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$4(arr);
+}
+function _iterable_to_array$4(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread$4() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array$4(arr) {
+    return _array_without_holes$4(arr) || _iterable_to_array$4(arr) || _unsupported_iterable_to_array$4(arr) || _non_iterable_spread$4();
+}
+function _unsupported_iterable_to_array$4(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$4(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$4(o, minLen);
+}
+/**
+ * Convenience function used to generate ModuleMetadata for an app's ZohoAccountsOAuthModule.
+ *
+ * Unlike `appZohoCrmModuleMetadata`, this needs no `ZohoAccountsAccessTokenCacheService` and
+ * therefore no dependency module: a per-user connect flow has no server token to cache.
+ *
+ * @param config - The module metadata configuration including an optional config factory.
+ * @returns NestJS ModuleMetadata for registering the ZohoAccountsOAuthApi.
+ */ function appZohoAccountsOAuthModuleMetadata(config$1) {
+    var _config_zohoAccountsOAuthServiceConfigFactory;
+    var imports = config$1.imports, exports$1 = config$1.exports, providers = config$1.providers;
+    return {
+        imports: [
+            config.ConfigModule
+        ].concat(_to_consumable_array$4(imports !== null && imports !== void 0 ? imports : [])),
+        exports: [
+            exports.ZohoAccountsOAuthApi
+        ].concat(_to_consumable_array$4(exports$1 !== null && exports$1 !== void 0 ? exports$1 : [])),
+        providers: [
+            {
+                provide: ZohoAccountsOAuthServiceConfig,
+                inject: [
+                    config.ConfigService
+                ],
+                useFactory: (_config_zohoAccountsOAuthServiceConfigFactory = config$1.zohoAccountsOAuthServiceConfigFactory) !== null && _config_zohoAccountsOAuthServiceConfigFactory !== void 0 ? _config_zohoAccountsOAuthServiceConfigFactory : zohoAccountsOAuthServiceConfigFactory
+            },
+            exports.ZohoAccountsOAuthApi
+        ].concat(_to_consumable_array$4(providers !== null && providers !== void 0 ? providers : []))
+    };
+}
+
 function _class_call_check$b(instance, Constructor) {
     if (!(instance instanceof Constructor)) {
         throw new TypeError("Cannot call a class as a function");
@@ -4328,16 +4636,21 @@ function _unsupported_iterable_to_array(o, minLen) {
 }
 
 exports.DEFAULT_FILE_ZOHO_ACCOUNTS_ACCESS_TOKEN_CACHE_SERVICE_PATH = DEFAULT_FILE_ZOHO_ACCOUNTS_ACCESS_TOKEN_CACHE_SERVICE_PATH;
+exports.ZOHO_ACCOUNTS_CLIENT_ID_CONFIG_KEY = ZOHO_ACCOUNTS_CLIENT_ID_CONFIG_KEY;
+exports.ZOHO_ACCOUNTS_CLIENT_SECRET_CONFIG_KEY = ZOHO_ACCOUNTS_CLIENT_SECRET_CONFIG_KEY;
+exports.ZOHO_ACCOUNTS_URL_CONFIG_KEY = ZOHO_ACCOUNTS_URL_CONFIG_KEY;
 exports.ZOHO_API_URL_CONFIG_KEY = ZOHO_API_URL_CONFIG_KEY;
 exports.ZOHO_ORG_ID_CONFIG_KEY = ZOHO_ORG_ID_CONFIG_KEY;
 exports.ZOHO_SIGN_WEBHOOK_SECRET_TOKEN_ENV_VAR = ZOHO_SIGN_WEBHOOK_SECRET_TOKEN_ENV_VAR;
 exports.ZOHO_SIGN_WEBHOOK_SIGNATURE_HEADER = ZOHO_SIGN_WEBHOOK_SIGNATURE_HEADER;
+exports.ZohoAccountsOAuthServiceConfig = ZohoAccountsOAuthServiceConfig;
 exports.ZohoAccountsServiceConfig = ZohoAccountsServiceConfig;
 exports.ZohoCrmServiceConfig = ZohoCrmServiceConfig;
 exports.ZohoDeskServiceConfig = ZohoDeskServiceConfig;
 exports.ZohoRecruitServiceConfig = ZohoRecruitServiceConfig;
 exports.ZohoSignServiceConfig = ZohoSignServiceConfig;
 exports.ZohoSignWebhookServiceConfig = ZohoSignWebhookServiceConfig;
+exports.appZohoAccountsOAuthModuleMetadata = appZohoAccountsOAuthModuleMetadata;
 exports.appZohoCrmModuleMetadata = appZohoCrmModuleMetadata;
 exports.appZohoDeskModuleMetadata = appZohoDeskModuleMetadata;
 exports.appZohoRecruitModuleMetadata = appZohoRecruitModuleMetadata;
@@ -4348,6 +4661,7 @@ exports.logMergeZohoAccountsAccessTokenCacheServiceErrorFunction = logMergeZohoA
 exports.memoryZohoAccountsAccessTokenCacheService = memoryZohoAccountsAccessTokenCacheService;
 exports.mergeZohoAccountsAccessTokenCacheServices = mergeZohoAccountsAccessTokenCacheServices;
 exports.readZohoConfigFromConfigService = readZohoConfigFromConfigService;
+exports.zohoAccountsOAuthServiceConfigFactory = zohoAccountsOAuthServiceConfigFactory;
 exports.zohoAccountsServiceConfigFromConfigService = zohoAccountsServiceConfigFromConfigService;
 exports.zohoConfigServiceReaderFunction = zohoConfigServiceReaderFunction;
 exports.zohoCrmAccountServiceConfigFactory = zohoCrmAccountServiceConfigFactory;