@dereekb/zoho 13.0.0 → 13.0.2

package/nestjs/index.esm.js

@@ -44,23 +44,24 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
 
 const ZOHO_API_URL_CONFIG_KEY = 'API_URL';
 function zohoConfigServiceReaderFunction(inputOrKey, inputConfigService) {
-  let configService;
-  let serviceAccessTokenKey;
-  if (typeof inputOrKey === 'string') {
-    serviceAccessTokenKey = inputOrKey;
-    configService = inputConfigService;
-  } else {
-    configService = inputOrKey.configService;
-    serviceAccessTokenKey = inputOrKey.serviceAccessTokenKey;
-  }
-  const baseServicePrefix = 'ZOHO_';
-  const servicePrefix = serviceAccessTokenKey.toUpperCase(); // "RECRUIT"
-  const servicePrefixString = `${baseServicePrefix}${servicePrefix}_`; // "ZOHO_RECRUIT_"
-  return key => {
-    const baseConfigKey = `${baseServicePrefix}${key}`; // "ZOHO_ACCOUNTS_URL"
-    const serviceSpecificConfigKey = `${servicePrefixString}${key}`; // "ZOHO_RECRUIT_ACCOUNTS_URL"
-    return configService.get(serviceSpecificConfigKey) ?? configService.get(baseConfigKey);
-  };
+    let configService;
+    let serviceAccessTokenKey;
+    if (typeof inputOrKey === 'string') {
+        serviceAccessTokenKey = inputOrKey;
+        configService = inputConfigService;
+    }
+    else {
+        configService = inputOrKey.configService;
+        serviceAccessTokenKey = inputOrKey.serviceAccessTokenKey;
+    }
+    const baseServicePrefix = 'ZOHO_';
+    const servicePrefix = serviceAccessTokenKey.toUpperCase(); // "RECRUIT"
+    const servicePrefixString = `${baseServicePrefix}${servicePrefix}_`; // "ZOHO_RECRUIT_"
+    return (key) => {
+        const baseConfigKey = `${baseServicePrefix}${key}`; // "ZOHO_ACCOUNTS_URL"
+        const serviceSpecificConfigKey = `${servicePrefixString}${key}`; // "ZOHO_RECRUIT_ACCOUNTS_URL"
+        return configService.get(serviceSpecificConfigKey) ?? configService.get(baseConfigKey);
+    };
 }
 /**
  * Reads the ZohoConfig config from the ConfigService.
@@ -69,48 +70,50 @@ function zohoConfigServiceReaderFunction(inputOrKey, inputConfigService) {
  * @param prefix
  */
 function readZohoConfigFromConfigService(configService, servicePrefix, assertValid = true) {
-  const servicePrefixString = servicePrefix ? `${servicePrefix}_` : '';
-  const apiUrlConfigKey = `${servicePrefixString}${ZOHO_API_URL_CONFIG_KEY}`;
-  const config = {
-    apiUrl: configService.get(apiUrlConfigKey) ?? configService.get(ZOHO_API_URL_CONFIG_KEY)
-  };
-  if (assertValid) {
-    if (!config.apiUrl) {
-      throw new Error(`No Zoho API url or type specified for key "${apiUrlConfigKey}".`);
+    const servicePrefixString = servicePrefix ? `${servicePrefix}_` : '';
+    const apiUrlConfigKey = `${servicePrefixString}${ZOHO_API_URL_CONFIG_KEY}`;
+    const config = {
+        apiUrl: configService.get(apiUrlConfigKey) ?? configService.get(ZOHO_API_URL_CONFIG_KEY)
+    };
+    if (assertValid) {
+        if (!config.apiUrl) {
+            throw new Error(`No Zoho API url or type specified for key "${apiUrlConfigKey}".`);
+        }
     }
-  }
-  return config;
+    return config;
 }
 function assertValidZohoConfig(config) {
-  if (!config.apiUrl) {
-    throw new Error(`No Zoho API url or type specified.`);
-  }
+    if (!config.apiUrl) {
+        throw new Error(`No Zoho API url or type specified.`);
+    }
 }
 
 /**
  * Configuration for ZohoService
  */
 class ZohoAccountsServiceConfig {
-  zohoAccounts;
-  factoryConfig;
-  static assertValidConfig(config) {
-    const {
-      zohoAccounts
-    } = config;
-    if (!zohoAccounts) {
-      throw new Error('ZohoAccountsServiceConfig.zohoAccounts is required');
-    } else {
-      if (!zohoAccounts.serviceAccessTokenKey) {
-        throw new Error('ZohoAccountsServiceConfig.zohoAccounts.serviceAccessTokenKey is required');
-      } else if (!zohoAccounts.refreshToken) {
-        throw new Error('ZohoAccountsServiceConfig.zohoAccounts.refreshToken is required');
-      } else if (!zohoAccounts.apiUrl) {
-        throw new Error('ZohoAccountsServiceConfig.zohoAccounts.apiUrl is required');
-      } else if (!zohoAccounts.clientId) {
-        throw new Error('ZohoAccountsServiceConfig.zohoAccounts.clientId is required');
-      }
-    }
-  }
+    zohoAccounts;
+    factoryConfig;
+    static assertValidConfig(config) {
+        const { zohoAccounts } = config;
+        if (!zohoAccounts) {
+            throw new Error('ZohoAccountsServiceConfig.zohoAccounts is required');
+        }
+        else {
+            if (!zohoAccounts.serviceAccessTokenKey) {
+                throw new Error('ZohoAccountsServiceConfig.zohoAccounts.serviceAccessTokenKey is required');
+            }
+            else if (!zohoAccounts.refreshToken) {
+                throw new Error('ZohoAccountsServiceConfig.zohoAccounts.refreshToken is required');
+            }
+            else if (!zohoAccounts.apiUrl) {
+                throw new Error('ZohoAccountsServiceConfig.zohoAccounts.apiUrl is required');
+            }
+            else if (!zohoAccounts.clientId) {
+                throw new Error('ZohoAccountsServiceConfig.zohoAccounts.clientId is required');
+            }
+        }
+    }
 }
 /**
  * Builds a {@link ZohoAccountsServiceConfig} by reading Zoho Accounts OAuth credentials
@@ -138,37 +141,35 @@ class ZohoAccountsServiceConfig {
  * @throws If any required credential (apiUrl, refreshToken, clientId) is missing.
  */
 function zohoAccountsServiceConfigFromConfigService(input) {
-  const {
-    serviceAccessTokenKey
-  } = input;
-  const getFromConfigService = zohoConfigServiceReaderFunction(input);
-  const zohoAccounts = {
-    serviceAccessTokenKey,
-    apiUrl: getFromConfigService('ACCOUNTS_URL'),
-    // ZOHO_<SERVICE>_ACCOUNTS_URL, ZOHO_ACCOUNTS_URL
-    refreshToken: getFromConfigService('ACCOUNTS_REFRESH_TOKEN'),
-    // ZOHO_<SERVICE>_ACCOUNTS_REFRESH_TOKEN, ZOHO_ACCOUNTS_REFRESH_TOKEN
-    clientId: getFromConfigService('ACCOUNTS_CLIENT_ID'),
-    // ZOHO_<SERVICE>_ACCOUNTS_CLIENT_ID, ZOHO_ACCOUNTS_CLIENT_ID
-    clientSecret: getFromConfigService('ACCOUNTS_CLIENT_SECRET') // ZOHO_<SERVICE>_ACCOUNTS_CLIENT_SECRET, ZOHO_ACCOUNTS_CLIENT_SECRET
-  };
-  const config = {
-    zohoAccounts
-  };
-  ZohoAccountsServiceConfig.assertValidConfig(config);
-  return config;
+    const { serviceAccessTokenKey } = input;
+    const getFromConfigService = zohoConfigServiceReaderFunction(input);
+    const zohoAccounts = {
+        serviceAccessTokenKey,
+        apiUrl: getFromConfigService('ACCOUNTS_URL'), // ZOHO_<SERVICE>_ACCOUNTS_URL, ZOHO_ACCOUNTS_URL
+        refreshToken: getFromConfigService('ACCOUNTS_REFRESH_TOKEN'), // ZOHO_<SERVICE>_ACCOUNTS_REFRESH_TOKEN, ZOHO_ACCOUNTS_REFRESH_TOKEN
+        clientId: getFromConfigService('ACCOUNTS_CLIENT_ID'), // ZOHO_<SERVICE>_ACCOUNTS_CLIENT_ID, ZOHO_ACCOUNTS_CLIENT_ID
+        clientSecret: getFromConfigService('ACCOUNTS_CLIENT_SECRET') // ZOHO_<SERVICE>_ACCOUNTS_CLIENT_SECRET, ZOHO_ACCOUNTS_CLIENT_SECRET
+    };
+    const config = {
+        zohoAccounts
+    };
+    ZohoAccountsServiceConfig.assertValidConfig(config);
+    return config;
 }
 
 /**
  * Service used for retrieving ZohoAccessTokenCache for Zoho services.
  */
-let ZohoAccountsAccessTokenCacheService = class ZohoAccountsAccessTokenCacheService {};
-ZohoAccountsAccessTokenCacheService = __decorate([Injectable()], ZohoAccountsAccessTokenCacheService);
+let ZohoAccountsAccessTokenCacheService = class ZohoAccountsAccessTokenCacheService {
+};
+ZohoAccountsAccessTokenCacheService = __decorate([
+    Injectable()
+], ZohoAccountsAccessTokenCacheService);
 function logMergeZohoAccountsAccessTokenCacheServiceErrorFunction(failedUpdates) {
-  console.warn(`mergeZohoAccountsAccessTokenCacheServices(): failed updating ${failedUpdates.length} caches.`);
-  failedUpdates.forEach(([x, e], i) => {
-    console.warn(`Cache update failure ${i + 1}: - ${e}`);
-  });
+    console.warn(`mergeZohoAccountsAccessTokenCacheServices(): failed updating ${failedUpdates.length} caches.`);
+    failedUpdates.forEach(([x, e], i) => {
+        console.warn(`Cache update failure ${i + 1}: - ${e}`);
+    });
 }
 /**
  * Merges the input services in order to use some as a backup source.
@@ -180,50 +181,56 @@ function logMergeZohoAccountsAccessTokenCacheServiceErrorFunction(failedUpdates)
  * @param servicesToMerge Must include atleast one service. Empty arrays will throw an error.
  */
 function mergeZohoAccountsAccessTokenCacheServices(inputServicesToMerge, logError) {
-  const services = [...inputServicesToMerge];
-  const logErrorFunction = typeof logError === 'function' ? logError : logError !== false ? logMergeZohoAccountsAccessTokenCacheServiceErrorFunction : undefined;
-  if (services.length === 0) {
-    throw new Error('mergeZohoAccountsAccessTokenCacheServices() input cannot be empty.');
-  }
-  const service = {
-    loadZohoAccessTokenCache: function (service) {
-      const accessCachesForServices = services.map(x => x.loadZohoAccessTokenCache(service));
-      const loadCachedTokenFromFirstService = tryWithPromiseFactoriesFunction({
-        promiseFactories: accessCachesForServices.map(x => () => x.loadCachedToken().catch(() => null).then(x => {
-          let result = undefined;
-          if (x && !isPast(x.expiresAt)) {
-            result = x; // only return from cache if it is not expired
-          }
-          return result;
-        })),
-        successOnMaybe: false,
-        throwErrors: false
-      });
-      const cacheForService = {
-        loadCachedToken: function () {
-          return loadCachedTokenFromFirstService();
-        },
-        updateCachedToken: async function (accessToken) {
-          return Promise.allSettled(accessCachesForServices.map(x => x.updateCachedToken(accessToken).then(() => null).catch(e => {
-            return [x, e];
-          }))).then(x => {
-            // only find the failures if we're logging
-            if (logErrorFunction != null) {
-              const failedUpdates = filterMaybeArrayValues(x.map(y => y.value));
-              if (failedUpdates.length) {
-                logErrorFunction(failedUpdates);
-              }
-            }
-          });
-        },
-        clearCachedToken: async function () {
-          await Promise.allSettled(accessCachesForServices.map(x => x.clearCachedToken()));
-        }
-      };
-      return cacheForService;
+    const services = [...inputServicesToMerge];
+    const logErrorFunction = typeof logError === 'function' ? logError : logError !== false ? logMergeZohoAccountsAccessTokenCacheServiceErrorFunction : undefined;
+    if (services.length === 0) {
+        throw new Error('mergeZohoAccountsAccessTokenCacheServices() input cannot be empty.');
     }
-  };
-  return service;
+    const service = {
+        loadZohoAccessTokenCache: function (service) {
+            const accessCachesForServices = services.map((x) => x.loadZohoAccessTokenCache(service));
+            const loadCachedTokenFromFirstService = tryWithPromiseFactoriesFunction({
+                promiseFactories: accessCachesForServices.map((x) => () => x
+                    .loadCachedToken()
+                    .catch(() => null)
+                    .then((x) => {
+                    let result = undefined;
+                    if (x && !isPast(x.expiresAt)) {
+                        result = x; // only return from cache if it is not expired
+                    }
+                    return result;
+                })),
+                successOnMaybe: false,
+                throwErrors: false
+            });
+            const cacheForService = {
+                loadCachedToken: function () {
+                    return loadCachedTokenFromFirstService();
+                },
+                updateCachedToken: async function (accessToken) {
+                    return Promise.allSettled(accessCachesForServices.map((x) => x
+                        .updateCachedToken(accessToken)
+                        .then(() => null)
+                        .catch((e) => {
+                        return [x, e];
+                    }))).then((x) => {
+                        // only find the failures if we're logging
+                        if (logErrorFunction != null) {
+                            const failedUpdates = filterMaybeArrayValues(x.map((y) => y.value));
+                            if (failedUpdates.length) {
+                                logErrorFunction(failedUpdates);
+                            }
+                        }
+                    });
+                },
+                clearCachedToken: async function () {
+                    await Promise.allSettled(accessCachesForServices.map((x) => x.clearCachedToken()));
+                }
+            };
+            return cacheForService;
+        }
+    };
+    return service;
 }
 // MARK: Memory Access Token Cache
 /**
@@ -232,42 +239,34 @@ function mergeZohoAccountsAccessTokenCacheServices(inputServicesToMerge, logErro
  * @returns
  */
 function memoryZohoAccountsAccessTokenCacheService(existingCache, logAccessToConsole) {
-  const tokens = existingCache ?? {};
-  function loadZohoAccessTokenCache(service) {
-    const accessTokenCache = {
-      loadCachedToken: async function () {
-        const token = tokens[service];
-        if (logAccessToConsole) {
-          console.log('retrieving access token from memory: ', {
-            token,
-            service
-          });
-        }
-        return token;
-      },
-      updateCachedToken: async function (accessToken) {
-        tokens[service] = accessToken;
-        if (logAccessToConsole) {
-          console.log('updating access token in memory: ', {
-            accessToken,
-            service
-          });
-        }
-      },
-      clearCachedToken: async function () {
-        delete tokens[service];
-        if (logAccessToConsole) {
-          console.log('clearing access token in memory: ', {
-            service
-          });
-        }
-      }
+    const tokens = existingCache ?? {};
+    function loadZohoAccessTokenCache(service) {
+        const accessTokenCache = {
+            loadCachedToken: async function () {
+                const token = tokens[service];
+                if (logAccessToConsole) {
+                    console.log('retrieving access token from memory: ', { token, service });
+                }
+                return token;
+            },
+            updateCachedToken: async function (accessToken) {
+                tokens[service] = accessToken;
+                if (logAccessToConsole) {
+                    console.log('updating access token in memory: ', { accessToken, service });
+                }
+            },
+            clearCachedToken: async function () {
+                delete tokens[service];
+                if (logAccessToConsole) {
+                    console.log('clearing access token in memory: ', { service });
+                }
+            }
+        };
+        return accessTokenCache;
+    }
+    return {
+        loadZohoAccessTokenCache
     };
-    return accessTokenCache;
-  }
-  return {
-    loadZohoAccessTokenCache
-  };
 }
 // MARK: File System Access Token Cache
 const DEFAULT_FILE_ZOHO_ACCOUNTS_ACCESS_TOKEN_CACHE_SERVICE_PATH = '.tmp/zoho-access-tokens.json';
@@ -279,273 +278,289 @@ const DEFAULT_FILE_ZOHO_ACCOUNTS_ACCESS_TOKEN_CACHE_SERVICE_PATH = '.tmp/zoho-ac
  * @returns
  */
 function fileZohoAccountsAccessTokenCacheService(filename = DEFAULT_FILE_ZOHO_ACCOUNTS_ACCESS_TOKEN_CACHE_SERVICE_PATH, useMemoryCache = true) {
-  let loadedTokens = null;
-  async function loadTokens() {
-    if (!loadedTokens) {
-      return (await readTokenFile()) ?? {};
-    } else {
-      return loadedTokens;
-    }
-  }
-  function readTokenFile() {
-    return new Promise(resolve => {
-      mkdirSync(dirname(filename), {
-        recursive: true
-      }); // make the directory first
-      readFile(filename, {}, (x, data) => {
-        let result = undefined;
-        if (!x) {
-          try {
-            result = JSON.parse(data.toString());
-            forEachKeyValue(result, {
-              forEach: x => {
-                if (x[1]) {
-                  x[1].expiresAt = new Date(x[1].expiresAt);
+    let loadedTokens = null;
+    async function loadTokens() {
+        if (!loadedTokens) {
+            return (await readTokenFile()) ?? {};
+        }
+        else {
+            return loadedTokens;
+        }
+    }
+    function readTokenFile() {
+        return new Promise((resolve) => {
+            mkdirSync(dirname(filename), { recursive: true }); // make the directory first
+            readFile(filename, {}, (x, data) => {
+                let result = undefined;
+                if (!x) {
+                    try {
+                        result = JSON.parse(data.toString());
+                        forEachKeyValue(result, {
+                            forEach: (x) => {
+                                if (x[1]) {
+                                    x[1].expiresAt = new Date(x[1].expiresAt);
+                                }
+                            }
+                        });
+                    }
+                    catch (e) {
+                        console.error('Failed reading token file: ', e);
+                    }
                 }
-              }
+                resolve(result);
             });
-          } catch (e) {
-            console.error('Failed reading token file: ', e);
-          }
-        }
-        resolve(result);
-      });
-    }).then(x => {
-      // update loaded tokens
-      if (useMemoryCache) {
-        loadedTokens = {
-          ...loadedTokens,
-          ...x
+        }).then((x) => {
+            // update loaded tokens
+            if (useMemoryCache) {
+                loadedTokens = {
+                    ...loadedTokens,
+                    ...x
+                };
+            }
+            return x;
+        });
+    }
+    async function writeTokenFile(tokens) {
+        return new Promise((resolve, reject) => {
+            writeFile(filename, JSON.stringify(tokens), {}, (x) => {
+                if (!x) {
+                    resolve();
+                }
+                else {
+                    reject(x);
+                }
+            });
+        });
+    }
+    async function deleteTokenFile() {
+        return new Promise((resolve, reject) => {
+            rm(filename, (x) => {
+                if (!x) {
+                    resolve();
+                }
+                else {
+                    reject(x);
+                }
+            });
+        });
+    }
+    function loadZohoAccessTokenCache(service) {
+        const accessTokenCache = {
+            loadCachedToken: async function () {
+                const tokens = await loadTokens();
+                const token = tokens[service];
+                // console.log('retrieving access token from file: ', { token, service });
+                return token;
+            },
+            updateCachedToken: async function (accessToken) {
+                const tokens = await loadTokens();
+                if (tokens) {
+                    tokens[service] = accessToken;
+                }
+                // console.log('updating access token in file: ', { accessToken, service });
+                try {
+                    await writeTokenFile(tokens);
+                }
+                catch (e) {
+                    console.error('Failed updating access token in file: ', e);
+                }
+            },
+            clearCachedToken: async function () {
+                try {
+                    await writeTokenFile({});
+                }
+                catch (e) {
+                    console.error('Failed clearing access token in file: ', e);
+                }
+            }
         };
-      }
-      return x;
-    });
-  }
-  async function writeTokenFile(tokens) {
-    return new Promise((resolve, reject) => {
-      writeFile(filename, JSON.stringify(tokens), {}, x => {
-        if (!x) {
-          resolve();
-        } else {
-          reject(x);
-        }
-      });
-    });
-  }
-  async function deleteTokenFile() {
-    return new Promise((resolve, reject) => {
-      rm(filename, x => {
-        if (!x) {
-          resolve();
-        } else {
-          reject(x);
-        }
-      });
-    });
-  }
-  function loadZohoAccessTokenCache(service) {
-    const accessTokenCache = {
-      loadCachedToken: async function () {
-        const tokens = await loadTokens();
-        const token = tokens[service];
-        // console.log('retrieving access token from file: ', { token, service });
-        return token;
-      },
-      updateCachedToken: async function (accessToken) {
-        const tokens = await loadTokens();
-        if (tokens) {
-          tokens[service] = accessToken;
-        }
-        // console.log('updating access token in file: ', { accessToken, service });
-        try {
-          await writeTokenFile(tokens);
-        } catch (e) {
-          console.error('Failed updating access token in file: ', e);
-        }
-      },
-      clearCachedToken: async function () {
-        try {
-          await writeTokenFile({});
-        } catch (e) {
-          console.error('Failed clearing access token in file: ', e);
-        }
-      }
+        return accessTokenCache;
+    }
+    return {
+        loadZohoAccessTokenCache,
+        readTokenFile,
+        writeTokenFile,
+        deleteTokenFile
     };
-    return accessTokenCache;
-  }
-  return {
-    loadZohoAccessTokenCache,
-    readTokenFile,
-    writeTokenFile,
-    deleteTokenFile
-  };
 }
 
 let ZohoAccountsApi = class ZohoAccountsApi {
-  config;
-  cacheService;
-  zohoAccounts;
-  get accountsContext() {
-    return this.zohoAccounts.accountsContext;
-  }
-  constructor(config, cacheService) {
-    this.config = config;
-    this.cacheService = cacheService;
-    const accessTokenCache = config.zohoAccounts.accessTokenCache ? config.zohoAccounts.accessTokenCache : cacheService.loadZohoAccessTokenCache(config.zohoAccounts.serviceAccessTokenKey);
-    this.zohoAccounts = zohoAccountsFactory(config.factoryConfig ?? {})({
-      accessTokenCache,
-      ...config.zohoAccounts
-    });
-  }
-  // MARK: Accessors
-  get accessToken() {
-    return zohoAccountsAccessToken(this.accountsContext);
-  }
+    config;
+    cacheService;
+    zohoAccounts;
+    get accountsContext() {
+        return this.zohoAccounts.accountsContext;
+    }
+    constructor(config, cacheService) {
+        this.config = config;
+        this.cacheService = cacheService;
+        const accessTokenCache = config.zohoAccounts.accessTokenCache ? config.zohoAccounts.accessTokenCache : cacheService.loadZohoAccessTokenCache(config.zohoAccounts.serviceAccessTokenKey);
+        this.zohoAccounts = zohoAccountsFactory(config.factoryConfig ?? {})({
+            accessTokenCache,
+            ...config.zohoAccounts
+        });
+    }
+    // MARK: Accessors
+    get accessToken() {
+        return zohoAccountsAccessToken(this.accountsContext);
+    }
 };
-ZohoAccountsApi = __decorate([Injectable(), __param(0, Inject(ZohoAccountsServiceConfig)), __param(1, Inject(ZohoAccountsAccessTokenCacheService)), __metadata("design:paramtypes", [ZohoAccountsServiceConfig, ZohoAccountsAccessTokenCacheService])], ZohoAccountsApi);
+ZohoAccountsApi = __decorate([
+    Injectable(),
+    __param(0, Inject(ZohoAccountsServiceConfig)),
+    __param(1, Inject(ZohoAccountsAccessTokenCacheService)),
+    __metadata("design:paramtypes", [ZohoAccountsServiceConfig,
+        ZohoAccountsAccessTokenCacheService])
+], ZohoAccountsApi);
 
 /**
  * Configuration for ZohoRecruitService
  */
 class ZohoRecruitServiceConfig {
-  zohoRecruit;
-  factoryConfig;
-  static assertValidConfig(config) {
-    assertValidZohoConfig(config.zohoRecruit);
-  }
+    zohoRecruit;
+    factoryConfig;
+    static assertValidConfig(config) {
+        assertValidZohoConfig(config.zohoRecruit);
+    }
 }
 
 let ZohoRecruitApi = class ZohoRecruitApi {
-  config;
-  zohoAccountsApi;
-  zohoRecruit;
-  get recruitContext() {
-    return this.zohoRecruit.recruitContext;
-  }
-  get zohoRateLimiter() {
-    return this.zohoRecruit.recruitContext.zohoRateLimiter;
-  }
-  constructor(config, zohoAccountsApi) {
-    this.config = config;
-    this.zohoAccountsApi = zohoAccountsApi;
-    this.zohoRecruit = zohoRecruitFactory({
-      ...config.factoryConfig,
-      accountsContext: zohoAccountsApi.accountsContext
-    })(config.zohoRecruit);
-  }
-  // MARK: Accessors
-  get insertRecord() {
-    return zohoRecruitInsertRecord(this.recruitContext);
-  }
-  get upsertRecord() {
-    return zohoRecruitUpsertRecord(this.recruitContext);
-  }
-  get updateRecord() {
-    return zohoRecruitUpdateRecord(this.recruitContext);
-  }
-  get deleteRecord() {
-    return zohoRecruitDeleteRecord(this.recruitContext);
-  }
-  get getRecordById() {
-    return zohoRecruitGetRecordById(this.recruitContext);
-  }
-  get getRecords() {
-    return zohoRecruitGetRecords(this.recruitContext);
-  }
-  get searchRecords() {
-    return zohoRecruitSearchRecords(this.recruitContext);
-  }
-  get searchRecordsPageFactory() {
-    return zohoRecruitSearchRecordsPageFactory(this.recruitContext);
-  }
-  get getRelatedRecordsFunctionFactory() {
-    return zohoRecruitGetRelatedRecordsFunctionFactory(this.recruitContext);
-  }
-  get getEmailsForRecord() {
-    return zohoRecruitGetEmailsForRecord(this.recruitContext);
-  }
-  get getEmailsForRecordPageFactory() {
-    return zohoRecruitGetEmailsForRecordPageFactory(this.recruitContext);
-  }
-  get getAttachmentsForRecord() {
-    return zohoRecruitGetAttachmentsForRecord(this.recruitContext);
-  }
-  get getAttachmentsForRecordPageFactory() {
-    return zohoRecruitGetAttachmentsForRecordPageFactory(this.recruitContext);
-  }
-  get uploadAttachmentForRecord() {
-    return zohoRecruitUploadAttachmentForRecord(this.recruitContext);
-  }
-  get downloadAttachmentForRecord() {
-    return zohoRecruitDownloadAttachmentForRecord(this.recruitContext);
-  }
-  get deleteAttachmentFromRecord() {
-    return zohoRecruitDeleteAttachmentFromRecord(this.recruitContext);
-  }
-  get createNotes() {
-    return zohoRecruitCreateNotes(this.recruitContext);
-  }
-  get deleteNotes() {
-    return zohoRecruitDeleteNotes(this.recruitContext);
-  }
-  get createNotesForRecord() {
-    return zohoRecruitCreateNotesForRecord(this.recruitContext);
-  }
-  get getNotesForRecord() {
-    return zohoRecruitGetNotesForRecord(this.recruitContext);
-  }
-  get getNotesForRecordPageFactory() {
-    return zohoRecruitGetNotesForRecordPageFactory(this.recruitContext);
-  }
-  get executeRestApiFunction() {
-    return zohoRecruitExecuteRestApiFunction(this.recruitContext);
-  }
-  get associateCandidateRecordsWithJobOpenings() {
-    return zohoRecruitAssociateCandidateRecordsWithJobOpenings(this.recruitContext);
-  }
-  get searchCandidateAssociatedJobOpeningRecords() {
-    return zohoRecruitSearchCandidateAssociatedJobOpeningRecords(this.recruitContext);
-  }
-  get searchCandidateAssociatedJobOpeningRecordsPageFactory() {
-    return zohoRecruitSearchCandidateAssociatedJobOpeningRecordsPageFactory(this.recruitContext);
-  }
-  get searchJobOpeningAssociatedCandidateRecords() {
-    return zohoRecruitSearchJobOpeningAssociatedCandidateRecords(this.recruitContext);
-  }
-  get searchJobOpeningAssociatedCandidateRecordsPageFactory() {
-    return zohoRecruitSearchJobOpeningAssociatedCandidateRecordsPageFactory(this.recruitContext);
-  }
-  get createTagsForModule() {
-    return zohoRecruitCreateTagsForModule(this.recruitContext);
-  }
-  get getTagsForModule() {
-    return zohoRecruitGetTagsForModule(this.recruitContext);
-  }
-  get addTagsToRecords() {
-    return zohoRecruitAddTagsToRecords(this.recruitContext);
-  }
-  get removeTagsFromRecords() {
-    return zohoRecruitRemoveTagsFromRecords(this.recruitContext);
-  }
+    config;
+    zohoAccountsApi;
+    zohoRecruit;
+    get recruitContext() {
+        return this.zohoRecruit.recruitContext;
+    }
+    get zohoRateLimiter() {
+        return this.zohoRecruit.recruitContext.zohoRateLimiter;
+    }
+    constructor(config, zohoAccountsApi) {
+        this.config = config;
+        this.zohoAccountsApi = zohoAccountsApi;
+        this.zohoRecruit = zohoRecruitFactory({
+            ...config.factoryConfig,
+            accountsContext: zohoAccountsApi.accountsContext
+        })(config.zohoRecruit);
+    }
+    // MARK: Accessors
+    get insertRecord() {
+        return zohoRecruitInsertRecord(this.recruitContext);
+    }
+    get upsertRecord() {
+        return zohoRecruitUpsertRecord(this.recruitContext);
+    }
+    get updateRecord() {
+        return zohoRecruitUpdateRecord(this.recruitContext);
+    }
+    get deleteRecord() {
+        return zohoRecruitDeleteRecord(this.recruitContext);
+    }
+    get getRecordById() {
+        return zohoRecruitGetRecordById(this.recruitContext);
+    }
+    get getRecords() {
+        return zohoRecruitGetRecords(this.recruitContext);
+    }
+    get searchRecords() {
+        return zohoRecruitSearchRecords(this.recruitContext);
+    }
+    get searchRecordsPageFactory() {
+        return zohoRecruitSearchRecordsPageFactory(this.recruitContext);
+    }
+    get getRelatedRecordsFunctionFactory() {
+        return zohoRecruitGetRelatedRecordsFunctionFactory(this.recruitContext);
+    }
+    get getEmailsForRecord() {
+        return zohoRecruitGetEmailsForRecord(this.recruitContext);
+    }
+    get getEmailsForRecordPageFactory() {
+        return zohoRecruitGetEmailsForRecordPageFactory(this.recruitContext);
+    }
+    get getAttachmentsForRecord() {
+        return zohoRecruitGetAttachmentsForRecord(this.recruitContext);
+    }
+    get getAttachmentsForRecordPageFactory() {
+        return zohoRecruitGetAttachmentsForRecordPageFactory(this.recruitContext);
+    }
+    get uploadAttachmentForRecord() {
+        return zohoRecruitUploadAttachmentForRecord(this.recruitContext);
+    }
+    get downloadAttachmentForRecord() {
+        return zohoRecruitDownloadAttachmentForRecord(this.recruitContext);
+    }
+    get deleteAttachmentFromRecord() {
+        return zohoRecruitDeleteAttachmentFromRecord(this.recruitContext);
+    }
+    get createNotes() {
+        return zohoRecruitCreateNotes(this.recruitContext);
+    }
+    get deleteNotes() {
+        return zohoRecruitDeleteNotes(this.recruitContext);
+    }
+    get createNotesForRecord() {
+        return zohoRecruitCreateNotesForRecord(this.recruitContext);
+    }
+    get getNotesForRecord() {
+        return zohoRecruitGetNotesForRecord(this.recruitContext);
+    }
+    get getNotesForRecordPageFactory() {
+        return zohoRecruitGetNotesForRecordPageFactory(this.recruitContext);
+    }
+    get executeRestApiFunction() {
+        return zohoRecruitExecuteRestApiFunction(this.recruitContext);
+    }
+    get associateCandidateRecordsWithJobOpenings() {
+        return zohoRecruitAssociateCandidateRecordsWithJobOpenings(this.recruitContext);
+    }
+    get searchCandidateAssociatedJobOpeningRecords() {
+        return zohoRecruitSearchCandidateAssociatedJobOpeningRecords(this.recruitContext);
+    }
+    get searchCandidateAssociatedJobOpeningRecordsPageFactory() {
+        return zohoRecruitSearchCandidateAssociatedJobOpeningRecordsPageFactory(this.recruitContext);
+    }
+    get searchJobOpeningAssociatedCandidateRecords() {
+        return zohoRecruitSearchJobOpeningAssociatedCandidateRecords(this.recruitContext);
+    }
+    get searchJobOpeningAssociatedCandidateRecordsPageFactory() {
+        return zohoRecruitSearchJobOpeningAssociatedCandidateRecordsPageFactory(this.recruitContext);
+    }
+    get createTagsForModule() {
+        return zohoRecruitCreateTagsForModule(this.recruitContext);
+    }
+    get getTagsForModule() {
+        return zohoRecruitGetTagsForModule(this.recruitContext);
+    }
+    get addTagsToRecords() {
+        return zohoRecruitAddTagsToRecords(this.recruitContext);
+    }
+    get removeTagsFromRecords() {
+        return zohoRecruitRemoveTagsFromRecords(this.recruitContext);
+    }
 };
-ZohoRecruitApi = __decorate([Injectable(), __param(0, Inject(ZohoRecruitServiceConfig)), __param(1, Inject(ZohoAccountsApi)), __metadata("design:paramtypes", [ZohoRecruitServiceConfig, ZohoAccountsApi])], ZohoRecruitApi);
+ZohoRecruitApi = __decorate([
+    Injectable(),
+    __param(0, Inject(ZohoRecruitServiceConfig)),
+    __param(1, Inject(ZohoAccountsApi)),
+    __metadata("design:paramtypes", [ZohoRecruitServiceConfig,
+        ZohoAccountsApi])
+], ZohoRecruitApi);
 
 // MARK: Provider Factories
 function zohoRecruitServiceConfigFactory(configService) {
-  const getFromConfigService = zohoConfigServiceReaderFunction(ZOHO_RECRUIT_SERVICE_NAME, configService);
-  const config = {
-    zohoRecruit: {
-      apiUrl: getFromConfigService(ZOHO_API_URL_CONFIG_KEY)
-    }
-  };
-  ZohoRecruitServiceConfig.assertValidConfig(config);
-  return config;
+    const getFromConfigService = zohoConfigServiceReaderFunction(ZOHO_RECRUIT_SERVICE_NAME, configService);
+    const config = {
+        zohoRecruit: {
+            apiUrl: getFromConfigService(ZOHO_API_URL_CONFIG_KEY)
+        }
+    };
+    ZohoRecruitServiceConfig.assertValidConfig(config);
+    return config;
 }
 function zohoRecruitAccountServiceConfigFactory(configService) {
-  return zohoAccountsServiceConfigFromConfigService({
-    configService,
-    serviceAccessTokenKey: ZOHO_RECRUIT_SERVICE_NAME
-  });
+    return zohoAccountsServiceConfigFromConfigService({
+        configService,
+        serviceAccessTokenKey: ZOHO_RECRUIT_SERVICE_NAME
+    });
 }
 /**
  * Convenience function used to generate ModuleMetadata for an app's ZohoRecruitModule.
@@ -555,28 +570,28 @@ function zohoRecruitAccountServiceConfigFactory(configService) {
  * @returns
  */
 function appZohoRecruitModuleMetadata(config) {
-  const {
-    dependencyModule,
-    imports,
-    exports: exports$1,
-    providers
-  } = config;
-  const dependencyModuleImport = dependencyModule ? [dependencyModule] : [];
-  return {
-    imports: [ConfigModule, ...dependencyModuleImport, ...(imports ?? [])],
-    exports: [ZohoRecruitApi, ...(exports$1 ?? [])],
-    providers: [{
-      provide: ZohoRecruitServiceConfig,
-      inject: [ConfigService],
-      useFactory: zohoRecruitServiceConfigFactory
-    }, ZohoRecruitApi,
-    // Accounts
-    {
-      provide: ZohoAccountsServiceConfig,
-      inject: [ConfigService],
-      useFactory: zohoRecruitAccountServiceConfigFactory
-    }, ZohoAccountsApi, ...(providers ?? [])]
-  };
+    const { dependencyModule, imports, exports: exports$1, providers } = config;
+    const dependencyModuleImport = dependencyModule ? [dependencyModule] : [];
+    return {
+        imports: [ConfigModule, ...dependencyModuleImport, ...(imports ?? [])],
+        exports: [ZohoRecruitApi, ...(exports$1 ?? [])],
+        providers: [
+            {
+                provide: ZohoRecruitServiceConfig,
+                inject: [ConfigService],
+                useFactory: zohoRecruitServiceConfigFactory
+            },
+            ZohoRecruitApi,
+            // Accounts
+            {
+                provide: ZohoAccountsServiceConfig,
+                inject: [ConfigService],
+                useFactory: zohoRecruitAccountServiceConfigFactory
+            },
+            ZohoAccountsApi,
+            ...(providers ?? [])
+        ]
+    };
 }
 
 export { DEFAULT_FILE_ZOHO_ACCOUNTS_ACCESS_TOKEN_CACHE_SERVICE_PATH, ZOHO_API_URL_CONFIG_KEY, ZohoAccountsAccessTokenCacheService, ZohoAccountsApi, ZohoAccountsServiceConfig, ZohoRecruitApi, ZohoRecruitServiceConfig, appZohoRecruitModuleMetadata, assertValidZohoConfig, fileZohoAccountsAccessTokenCacheService, logMergeZohoAccountsAccessTokenCacheServiceErrorFunction, memoryZohoAccountsAccessTokenCacheService, mergeZohoAccountsAccessTokenCacheServices, readZohoConfigFromConfigService, zohoAccountsServiceConfigFromConfigService, zohoConfigServiceReaderFunction, zohoRecruitAccountServiceConfigFactory, zohoRecruitServiceConfigFactory };