@dereekb/zoho 13.0.0 → 13.0.2

package/nestjs/index.cjs.js

@@ -46,23 +46,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.
@@ -71,48 +72,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
@@ -140,37 +143,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.
  */
-exports.ZohoAccountsAccessTokenCacheService = class ZohoAccountsAccessTokenCacheService {};
-exports.ZohoAccountsAccessTokenCacheService = __decorate([common.Injectable()], exports.ZohoAccountsAccessTokenCacheService);
+exports.ZohoAccountsAccessTokenCacheService = class ZohoAccountsAccessTokenCacheService {
+};
+exports.ZohoAccountsAccessTokenCacheService = __decorate([
+    common.Injectable()
+], exports.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.
@@ -182,50 +183,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 = util.tryWithPromiseFactoriesFunction({
-        promiseFactories: accessCachesForServices.map(x => () => x.loadCachedToken().catch(() => null).then(x => {
-          let result = undefined;
-          if (x && !util.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 = util.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 = util.tryWithPromiseFactoriesFunction({
+                promiseFactories: accessCachesForServices.map((x) => () => x
+                    .loadCachedToken()
+                    .catch(() => null)
+                    .then((x) => {
+                    let result = undefined;
+                    if (x && !util.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 = util.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
 /**
@@ -234,42 +241,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';
@@ -281,273 +280,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 => {
-      fs.mkdirSync(path.dirname(filename), {
-        recursive: true
-      }); // make the directory first
-      fs.readFile(filename, {}, (x, data) => {
-        let result = undefined;
-        if (!x) {
-          try {
-            result = JSON.parse(data.toString());
-            util.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) => {
+            fs.mkdirSync(path.dirname(filename), { recursive: true }); // make the directory first
+            fs.readFile(filename, {}, (x, data) => {
+                let result = undefined;
+                if (!x) {
+                    try {
+                        result = JSON.parse(data.toString());
+                        util.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) => {
+            fs.writeFile(filename, JSON.stringify(tokens), {}, (x) => {
+                if (!x) {
+                    resolve();
+                }
+                else {
+                    reject(x);
+                }
+            });
+        });
+    }
+    async function deleteTokenFile() {
+        return new Promise((resolve, reject) => {
+            fs.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) => {
-      fs.writeFile(filename, JSON.stringify(tokens), {}, x => {
-        if (!x) {
-          resolve();
-        } else {
-          reject(x);
-        }
-      });
-    });
-  }
-  async function deleteTokenFile() {
-    return new Promise((resolve, reject) => {
-      fs.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
-  };
 }
 
 exports.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 = zoho.zohoAccountsFactory(config.factoryConfig ?? {})({
-      accessTokenCache,
-      ...config.zohoAccounts
-    });
-  }
-  // MARK: Accessors
-  get accessToken() {
-    return zoho.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 = zoho.zohoAccountsFactory(config.factoryConfig ?? {})({
+            accessTokenCache,
+            ...config.zohoAccounts
+        });
+    }
+    // MARK: Accessors
+    get accessToken() {
+        return zoho.zohoAccountsAccessToken(this.accountsContext);
+    }
 };
-exports.ZohoAccountsApi = __decorate([common.Injectable(), __param(0, common.Inject(ZohoAccountsServiceConfig)), __param(1, common.Inject(exports.ZohoAccountsAccessTokenCacheService)), __metadata("design:paramtypes", [ZohoAccountsServiceConfig, exports.ZohoAccountsAccessTokenCacheService])], exports.ZohoAccountsApi);
+exports.ZohoAccountsApi = __decorate([
+    common.Injectable(),
+    __param(0, common.Inject(ZohoAccountsServiceConfig)),
+    __param(1, common.Inject(exports.ZohoAccountsAccessTokenCacheService)),
+    __metadata("design:paramtypes", [ZohoAccountsServiceConfig,
+        exports.ZohoAccountsAccessTokenCacheService])
+], exports.ZohoAccountsApi);
 
 /**
  * Configuration for ZohoRecruitService
  */
 class ZohoRecruitServiceConfig {
-  zohoRecruit;
-  factoryConfig;
-  static assertValidConfig(config) {
-    assertValidZohoConfig(config.zohoRecruit);
-  }
+    zohoRecruit;
+    factoryConfig;
+    static assertValidConfig(config) {
+        assertValidZohoConfig(config.zohoRecruit);
+    }
 }
 
 exports.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 = zoho.zohoRecruitFactory({
-      ...config.factoryConfig,
-      accountsContext: zohoAccountsApi.accountsContext
-    })(config.zohoRecruit);
-  }
-  // MARK: Accessors
-  get insertRecord() {
-    return zoho.zohoRecruitInsertRecord(this.recruitContext);
-  }
-  get upsertRecord() {
-    return zoho.zohoRecruitUpsertRecord(this.recruitContext);
-  }
-  get updateRecord() {
-    return zoho.zohoRecruitUpdateRecord(this.recruitContext);
-  }
-  get deleteRecord() {
-    return zoho.zohoRecruitDeleteRecord(this.recruitContext);
-  }
-  get getRecordById() {
-    return zoho.zohoRecruitGetRecordById(this.recruitContext);
-  }
-  get getRecords() {
-    return zoho.zohoRecruitGetRecords(this.recruitContext);
-  }
-  get searchRecords() {
-    return zoho.zohoRecruitSearchRecords(this.recruitContext);
-  }
-  get searchRecordsPageFactory() {
-    return zoho.zohoRecruitSearchRecordsPageFactory(this.recruitContext);
-  }
-  get getRelatedRecordsFunctionFactory() {
-    return zoho.zohoRecruitGetRelatedRecordsFunctionFactory(this.recruitContext);
-  }
-  get getEmailsForRecord() {
-    return zoho.zohoRecruitGetEmailsForRecord(this.recruitContext);
-  }
-  get getEmailsForRecordPageFactory() {
-    return zoho.zohoRecruitGetEmailsForRecordPageFactory(this.recruitContext);
-  }
-  get getAttachmentsForRecord() {
-    return zoho.zohoRecruitGetAttachmentsForRecord(this.recruitContext);
-  }
-  get getAttachmentsForRecordPageFactory() {
-    return zoho.zohoRecruitGetAttachmentsForRecordPageFactory(this.recruitContext);
-  }
-  get uploadAttachmentForRecord() {
-    return zoho.zohoRecruitUploadAttachmentForRecord(this.recruitContext);
-  }
-  get downloadAttachmentForRecord() {
-    return zoho.zohoRecruitDownloadAttachmentForRecord(this.recruitContext);
-  }
-  get deleteAttachmentFromRecord() {
-    return zoho.zohoRecruitDeleteAttachmentFromRecord(this.recruitContext);
-  }
-  get createNotes() {
-    return zoho.zohoRecruitCreateNotes(this.recruitContext);
-  }
-  get deleteNotes() {
-    return zoho.zohoRecruitDeleteNotes(this.recruitContext);
-  }
-  get createNotesForRecord() {
-    return zoho.zohoRecruitCreateNotesForRecord(this.recruitContext);
-  }
-  get getNotesForRecord() {
-    return zoho.zohoRecruitGetNotesForRecord(this.recruitContext);
-  }
-  get getNotesForRecordPageFactory() {
-    return zoho.zohoRecruitGetNotesForRecordPageFactory(this.recruitContext);
-  }
-  get executeRestApiFunction() {
-    return zoho.zohoRecruitExecuteRestApiFunction(this.recruitContext);
-  }
-  get associateCandidateRecordsWithJobOpenings() {
-    return zoho.zohoRecruitAssociateCandidateRecordsWithJobOpenings(this.recruitContext);
-  }
-  get searchCandidateAssociatedJobOpeningRecords() {
-    return zoho.zohoRecruitSearchCandidateAssociatedJobOpeningRecords(this.recruitContext);
-  }
-  get searchCandidateAssociatedJobOpeningRecordsPageFactory() {
-    return zoho.zohoRecruitSearchCandidateAssociatedJobOpeningRecordsPageFactory(this.recruitContext);
-  }
-  get searchJobOpeningAssociatedCandidateRecords() {
-    return zoho.zohoRecruitSearchJobOpeningAssociatedCandidateRecords(this.recruitContext);
-  }
-  get searchJobOpeningAssociatedCandidateRecordsPageFactory() {
-    return zoho.zohoRecruitSearchJobOpeningAssociatedCandidateRecordsPageFactory(this.recruitContext);
-  }
-  get createTagsForModule() {
-    return zoho.zohoRecruitCreateTagsForModule(this.recruitContext);
-  }
-  get getTagsForModule() {
-    return zoho.zohoRecruitGetTagsForModule(this.recruitContext);
-  }
-  get addTagsToRecords() {
-    return zoho.zohoRecruitAddTagsToRecords(this.recruitContext);
-  }
-  get removeTagsFromRecords() {
-    return zoho.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 = zoho.zohoRecruitFactory({
+            ...config.factoryConfig,
+            accountsContext: zohoAccountsApi.accountsContext
+        })(config.zohoRecruit);
+    }
+    // MARK: Accessors
+    get insertRecord() {
+        return zoho.zohoRecruitInsertRecord(this.recruitContext);
+    }
+    get upsertRecord() {
+        return zoho.zohoRecruitUpsertRecord(this.recruitContext);
+    }
+    get updateRecord() {
+        return zoho.zohoRecruitUpdateRecord(this.recruitContext);
+    }
+    get deleteRecord() {
+        return zoho.zohoRecruitDeleteRecord(this.recruitContext);
+    }
+    get getRecordById() {
+        return zoho.zohoRecruitGetRecordById(this.recruitContext);
+    }
+    get getRecords() {
+        return zoho.zohoRecruitGetRecords(this.recruitContext);
+    }
+    get searchRecords() {
+        return zoho.zohoRecruitSearchRecords(this.recruitContext);
+    }
+    get searchRecordsPageFactory() {
+        return zoho.zohoRecruitSearchRecordsPageFactory(this.recruitContext);
+    }
+    get getRelatedRecordsFunctionFactory() {
+        return zoho.zohoRecruitGetRelatedRecordsFunctionFactory(this.recruitContext);
+    }
+    get getEmailsForRecord() {
+        return zoho.zohoRecruitGetEmailsForRecord(this.recruitContext);
+    }
+    get getEmailsForRecordPageFactory() {
+        return zoho.zohoRecruitGetEmailsForRecordPageFactory(this.recruitContext);
+    }
+    get getAttachmentsForRecord() {
+        return zoho.zohoRecruitGetAttachmentsForRecord(this.recruitContext);
+    }
+    get getAttachmentsForRecordPageFactory() {
+        return zoho.zohoRecruitGetAttachmentsForRecordPageFactory(this.recruitContext);
+    }
+    get uploadAttachmentForRecord() {
+        return zoho.zohoRecruitUploadAttachmentForRecord(this.recruitContext);
+    }
+    get downloadAttachmentForRecord() {
+        return zoho.zohoRecruitDownloadAttachmentForRecord(this.recruitContext);
+    }
+    get deleteAttachmentFromRecord() {
+        return zoho.zohoRecruitDeleteAttachmentFromRecord(this.recruitContext);
+    }
+    get createNotes() {
+        return zoho.zohoRecruitCreateNotes(this.recruitContext);
+    }
+    get deleteNotes() {
+        return zoho.zohoRecruitDeleteNotes(this.recruitContext);
+    }
+    get createNotesForRecord() {
+        return zoho.zohoRecruitCreateNotesForRecord(this.recruitContext);
+    }
+    get getNotesForRecord() {
+        return zoho.zohoRecruitGetNotesForRecord(this.recruitContext);
+    }
+    get getNotesForRecordPageFactory() {
+        return zoho.zohoRecruitGetNotesForRecordPageFactory(this.recruitContext);
+    }
+    get executeRestApiFunction() {
+        return zoho.zohoRecruitExecuteRestApiFunction(this.recruitContext);
+    }
+    get associateCandidateRecordsWithJobOpenings() {
+        return zoho.zohoRecruitAssociateCandidateRecordsWithJobOpenings(this.recruitContext);
+    }
+    get searchCandidateAssociatedJobOpeningRecords() {
+        return zoho.zohoRecruitSearchCandidateAssociatedJobOpeningRecords(this.recruitContext);
+    }
+    get searchCandidateAssociatedJobOpeningRecordsPageFactory() {
+        return zoho.zohoRecruitSearchCandidateAssociatedJobOpeningRecordsPageFactory(this.recruitContext);
+    }
+    get searchJobOpeningAssociatedCandidateRecords() {
+        return zoho.zohoRecruitSearchJobOpeningAssociatedCandidateRecords(this.recruitContext);
+    }
+    get searchJobOpeningAssociatedCandidateRecordsPageFactory() {
+        return zoho.zohoRecruitSearchJobOpeningAssociatedCandidateRecordsPageFactory(this.recruitContext);
+    }
+    get createTagsForModule() {
+        return zoho.zohoRecruitCreateTagsForModule(this.recruitContext);
+    }
+    get getTagsForModule() {
+        return zoho.zohoRecruitGetTagsForModule(this.recruitContext);
+    }
+    get addTagsToRecords() {
+        return zoho.zohoRecruitAddTagsToRecords(this.recruitContext);
+    }
+    get removeTagsFromRecords() {
+        return zoho.zohoRecruitRemoveTagsFromRecords(this.recruitContext);
+    }
 };
-exports.ZohoRecruitApi = __decorate([common.Injectable(), __param(0, common.Inject(ZohoRecruitServiceConfig)), __param(1, common.Inject(exports.ZohoAccountsApi)), __metadata("design:paramtypes", [ZohoRecruitServiceConfig, exports.ZohoAccountsApi])], exports.ZohoRecruitApi);
+exports.ZohoRecruitApi = __decorate([
+    common.Injectable(),
+    __param(0, common.Inject(ZohoRecruitServiceConfig)),
+    __param(1, common.Inject(exports.ZohoAccountsApi)),
+    __metadata("design:paramtypes", [ZohoRecruitServiceConfig,
+        exports.ZohoAccountsApi])
+], exports.ZohoRecruitApi);
 
 // MARK: Provider Factories
 function zohoRecruitServiceConfigFactory(configService) {
-  const getFromConfigService = zohoConfigServiceReaderFunction(zoho.ZOHO_RECRUIT_SERVICE_NAME, configService);
-  const config = {
-    zohoRecruit: {
-      apiUrl: getFromConfigService(ZOHO_API_URL_CONFIG_KEY)
-    }
-  };
-  ZohoRecruitServiceConfig.assertValidConfig(config);
-  return config;
+    const getFromConfigService = zohoConfigServiceReaderFunction(zoho.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.ZOHO_RECRUIT_SERVICE_NAME
-  });
+    return zohoAccountsServiceConfigFromConfigService({
+        configService,
+        serviceAccessTokenKey: zoho.ZOHO_RECRUIT_SERVICE_NAME
+    });
 }
 /**
  * Convenience function used to generate ModuleMetadata for an app's ZohoRecruitModule.
@@ -557,28 +572,28 @@ function zohoRecruitAccountServiceConfigFactory(configService) {
  * @returns
  */
 function appZohoRecruitModuleMetadata(config$1) {
-  const {
-    dependencyModule,
-    imports,
-    exports: exports$1,
-    providers
-  } = config$1;
-  const dependencyModuleImport = dependencyModule ? [dependencyModule] : [];
-  return {
-    imports: [config.ConfigModule, ...dependencyModuleImport, ...(imports ?? [])],
-    exports: [exports.ZohoRecruitApi, ...(exports$1 ?? [])],
-    providers: [{
-      provide: ZohoRecruitServiceConfig,
-      inject: [config.ConfigService],
-      useFactory: zohoRecruitServiceConfigFactory
-    }, exports.ZohoRecruitApi,
-    // Accounts
-    {
-      provide: ZohoAccountsServiceConfig,
-      inject: [config.ConfigService],
-      useFactory: zohoRecruitAccountServiceConfigFactory
-    }, exports.ZohoAccountsApi, ...(providers ?? [])]
-  };
+    const { dependencyModule, imports, exports: exports$1, providers } = config$1;
+    const dependencyModuleImport = dependencyModule ? [dependencyModule] : [];
+    return {
+        imports: [config.ConfigModule, ...dependencyModuleImport, ...(imports ?? [])],
+        exports: [exports.ZohoRecruitApi, ...(exports$1 ?? [])],
+        providers: [
+            {
+                provide: ZohoRecruitServiceConfig,
+                inject: [config.ConfigService],
+                useFactory: zohoRecruitServiceConfigFactory
+            },
+            exports.ZohoRecruitApi,
+            // Accounts
+            {
+                provide: ZohoAccountsServiceConfig,
+                inject: [config.ConfigService],
+                useFactory: zohoRecruitAccountServiceConfigFactory
+            },
+            exports.ZohoAccountsApi,
+            ...(providers ?? [])
+        ]
+    };
 }
 
 exports.DEFAULT_FILE_ZOHO_ACCOUNTS_ACCESS_TOKEN_CACHE_SERVICE_PATH = DEFAULT_FILE_ZOHO_ACCOUNTS_ACCESS_TOKEN_CACHE_SERVICE_PATH;