@dereekb/zoom 13.0.0 → 13.0.2

package/nestjs/index.cjs.js

@@ -50,58 +50,59 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
  * Configuration for ZoomService
  */
 class ZoomOAuthServiceConfig {
-  zoomOAuth;
-  factoryConfig;
-  static assertValidConfig(config) {
-    const {
-      zoomOAuth
-    } = config;
-    if (!zoomOAuth) {
-      throw new Error('ZoomOAuthServiceConfig.zoomOAuth is required');
-    } else {
-      if (!zoomOAuth.accountId) {
-        throw new Error('ZoomOAuthServiceConfig.zoomOAuth.accountId is required');
-      } else if (!zoomOAuth.clientSecret) {
-        throw new Error('ZoomOAuthServiceConfig.zoomOAuth.clientSecret is required');
-      } else if (!zoomOAuth.clientId) {
-        throw new Error('ZoomOAuthServiceConfig.zoomOAuth.clientId is required');
-      }
-    }
-  }
+    zoomOAuth;
+    factoryConfig;
+    static assertValidConfig(config) {
+        const { zoomOAuth } = config;
+        if (!zoomOAuth) {
+            throw new Error('ZoomOAuthServiceConfig.zoomOAuth is required');
+        }
+        else {
+            if (!zoomOAuth.accountId) {
+                throw new Error('ZoomOAuthServiceConfig.zoomOAuth.accountId is required');
+            }
+            else if (!zoomOAuth.clientSecret) {
+                throw new Error('ZoomOAuthServiceConfig.zoomOAuth.clientSecret is required');
+            }
+            else if (!zoomOAuth.clientId) {
+                throw new Error('ZoomOAuthServiceConfig.zoomOAuth.clientId is required');
+            }
+        }
+    }
 }
 function readZoomOAuthServiceConfigFromConfigService(configService, prefix) {
-  const prefixString = util.characterPrefixSuffixInstance({
-    suffix: '_',
-    suffixEmptyString: false
-  }).prefixSuffixString(prefix ?? '');
-  const accountIdKey = `${prefixString}ZOOM_ACCOUNT_ID`;
-  const clientIdKey = `${prefixString}ZOOM_CLIENT_ID`;
-  const clientSecretKey = `${prefixString}ZOOM_CLIENT_SECRET`;
-  const accountId = configService.getOrThrow(accountIdKey);
-  const clientId = configService.getOrThrow(clientIdKey);
-  const clientSecret = configService.getOrThrow(clientSecretKey);
-  const config = {
-    zoomOAuth: {
-      authEntityType: 'account',
-      accountId,
-      clientId,
-      clientSecret
-    }
-  };
-  ZoomOAuthServiceConfig.assertValidConfig(config);
-  return config;
+    const prefixString = util.characterPrefixSuffixInstance({ suffix: '_', suffixEmptyString: false }).prefixSuffixString(prefix ?? '');
+    const accountIdKey = `${prefixString}ZOOM_ACCOUNT_ID`;
+    const clientIdKey = `${prefixString}ZOOM_CLIENT_ID`;
+    const clientSecretKey = `${prefixString}ZOOM_CLIENT_SECRET`;
+    const accountId = configService.getOrThrow(accountIdKey);
+    const clientId = configService.getOrThrow(clientIdKey);
+    const clientSecret = configService.getOrThrow(clientSecretKey);
+    const config = {
+        zoomOAuth: {
+            authEntityType: 'account',
+            accountId,
+            clientId,
+            clientSecret
+        }
+    };
+    ZoomOAuthServiceConfig.assertValidConfig(config);
+    return config;
 }
 
 /**
  * Service used for retrieving ZoomAccessTokenCache for Zoom services.
  */
-exports.ZoomOAuthAccessTokenCacheService = class ZoomOAuthAccessTokenCacheService {};
-exports.ZoomOAuthAccessTokenCacheService = __decorate([common.Injectable()], exports.ZoomOAuthAccessTokenCacheService);
+exports.ZoomOAuthAccessTokenCacheService = class ZoomOAuthAccessTokenCacheService {
+};
+exports.ZoomOAuthAccessTokenCacheService = __decorate([
+    common.Injectable()
+], exports.ZoomOAuthAccessTokenCacheService);
 function logMergeZoomOAuthAccessTokenCacheServiceErrorFunction(failedUpdates) {
-  console.warn(`mergeZoomOAuthAccessTokenCacheServices(): failed updating ${failedUpdates.length} caches.`);
-  failedUpdates.forEach(([x, e], i) => {
-    console.warn(`Cache update failure ${i + 1}: - ${e}`);
-  });
+    console.warn(`mergeZoomOAuthAccessTokenCacheServices(): 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.
@@ -113,54 +114,62 @@ function logMergeZoomOAuthAccessTokenCacheServiceErrorFunction(failedUpdates) {
  * @param servicesToMerge Must include atleast one service. Empty arrays will throw an error.
  */
 function mergeZoomOAuthAccessTokenCacheServices(inputServicesToMerge, logError) {
-  const allServices = [...inputServicesToMerge];
-  const logErrorFunction = typeof logError === 'function' ? logError : logError !== false ? logMergeZoomOAuthAccessTokenCacheServiceErrorFunction : undefined;
-  if (allServices.length === 0) {
-    throw new Error('mergeZoomOAuthAccessTokenCacheServices() input cannot be empty.');
-  }
-  const loadZoomAccessTokenCache = accessCachesForServices => {
-    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);
-            }
-          }
+    const allServices = [...inputServicesToMerge];
+    const logErrorFunction = typeof logError === 'function' ? logError : logError !== false ? logMergeZoomOAuthAccessTokenCacheServiceErrorFunction : undefined;
+    if (allServices.length === 0) {
+        throw new Error('mergeZoomOAuthAccessTokenCacheServices() input cannot be empty.');
+    }
+    const loadZoomAccessTokenCache = (accessCachesForServices) => {
+        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);
+                        }
+                    }
+                });
+            }
+        };
+        return cacheForService;
+    };
+    const allServiceAccessTokenCaches = allServices.map((x) => x.loadZoomAccessTokenCache());
+    const allServicesWithCacheForRefreshToken = allServices.filter((x) => x.cacheForRefreshToken != null);
+    const cacheForRefreshToken = allServiceAccessTokenCaches.length > 0
+        ? (refreshToken) => {
+            const allCaches = allServicesWithCacheForRefreshToken.map((x) => x.cacheForRefreshToken(refreshToken));
+            return loadZoomAccessTokenCache(allCaches);
+        }
+        : undefined;
+    const service = {
+        loadZoomAccessTokenCache: () => loadZoomAccessTokenCache(allServiceAccessTokenCaches),
+        cacheForRefreshToken
     };
-    return cacheForService;
-  };
-  const allServiceAccessTokenCaches = allServices.map(x => x.loadZoomAccessTokenCache());
-  const allServicesWithCacheForRefreshToken = allServices.filter(x => x.cacheForRefreshToken != null);
-  const cacheForRefreshToken = allServiceAccessTokenCaches.length > 0 ? refreshToken => {
-    const allCaches = allServicesWithCacheForRefreshToken.map(x => x.cacheForRefreshToken(refreshToken));
-    return loadZoomAccessTokenCache(allCaches);
-  } : undefined;
-  const service = {
-    loadZoomAccessTokenCache: () => loadZoomAccessTokenCache(allServiceAccessTokenCaches),
-    cacheForRefreshToken
-  };
-  return service;
+    return service;
 }
 // MARK: Memory Access Token Cache
 /**
@@ -169,32 +178,28 @@ function mergeZoomOAuthAccessTokenCacheServices(inputServicesToMerge, logError)
  * @returns
  */
 function memoryZoomOAuthAccessTokenCacheService(existingToken, logAccessToConsole) {
-  let token = existingToken;
-  function loadZoomAccessTokenCache() {
-    const accessTokenCache = {
-      loadCachedToken: async function () {
-        if (logAccessToConsole) {
-          console.log('retrieving access token from memory: ', {
-            token
-          });
-        }
-        return token;
-      },
-      updateCachedToken: async function (accessToken) {
-        token = accessToken;
-        if (logAccessToConsole) {
-          console.log('updating access token in memory: ', {
-            accessToken
-          });
-        }
-      }
+    let token = existingToken;
+    function loadZoomAccessTokenCache() {
+        const accessTokenCache = {
+            loadCachedToken: async function () {
+                if (logAccessToConsole) {
+                    console.log('retrieving access token from memory: ', { token });
+                }
+                return token;
+            },
+            updateCachedToken: async function (accessToken) {
+                token = accessToken;
+                if (logAccessToConsole) {
+                    console.log('updating access token in memory: ', { accessToken });
+                }
+            }
+        };
+        return accessTokenCache;
+    }
+    return {
+        loadZoomAccessTokenCache,
+        cacheForRefreshToken: () => loadZoomAccessTokenCache()
     };
-    return accessTokenCache;
-  }
-  return {
-    loadZoomAccessTokenCache,
-    cacheForRefreshToken: () => loadZoomAccessTokenCache()
-  };
 }
 // MARK: File System Access Token Cache
 const DEFAULT_FILE_ZOOM_ACCOUNTS_ACCESS_TOKEN_CACHE_SERVICE_PATH = '.tmp/zoom-access-tokens.json';
@@ -206,128 +211,137 @@ const DEFAULT_FILE_ZOOM_ACCOUNTS_ACCESS_TOKEN_CACHE_SERVICE_PATH = '.tmp/zoom-ac
  * @returns
  */
 function fileZoomOAuthAccessTokenCacheService(filename = DEFAULT_FILE_ZOOM_ACCOUNTS_ACCESS_TOKEN_CACHE_SERVICE_PATH, useMemoryCache = true) {
-  let loadedToken = null;
-  async function loadTokenFile() {
-    let token = undefined;
-    if (!loadedToken) {
-      token = (await readTokenFile()) ?? {};
-    } else {
-      token = loadedToken;
-    }
-    return token;
-  }
-  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());
-            if (result?.token) {
-              result.token.expiresAt = new Date(result.token.expiresAt);
-            }
-          } catch (e) {
-            console.error('Failed reading token file: ', e);
-          }
-        }
-        resolve(result);
-      });
-    }).then(x => {
-      // update loaded tokens
-      if (useMemoryCache) {
-        loadedToken = {
-          ...loadedToken,
-          ...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);
+    let loadedToken = null;
+    async function loadTokenFile() {
+        let token = undefined;
+        if (!loadedToken) {
+            token = (await readTokenFile()) ?? {};
         }
-      });
-    });
-  }
-  async function deleteTokenFile() {
-    return new Promise((resolve, reject) => {
-      fs.rm(filename, x => {
-        if (!x) {
-          resolve();
-        } else {
-          reject(x);
+        else {
+            token = loadedToken;
         }
-      });
-    });
-  }
-  function loadZoomAccessTokenCache() {
-    const accessTokenCache = {
-      loadCachedToken: async function () {
-        const tokens = await loadTokenFile();
-        const token = tokens.token;
-        // console.log('retrieving access token from file: ', { token });
         return token;
-      },
-      updateCachedToken: async function (accessToken) {
-        const tokenFile = await loadTokenFile();
-        if (tokenFile) {
-          tokenFile.token = accessToken;
-        }
-        // console.log('updating access token in file: ', { accessToken });
-        try {
-          await writeTokenFile(tokenFile);
-        } catch (e) {
-          console.error('Failed updating access token in file: ', e);
-        }
-      }
+    }
+    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());
+                        if (result?.token) {
+                            result.token.expiresAt = new Date(result.token.expiresAt);
+                        }
+                    }
+                    catch (e) {
+                        console.error('Failed reading token file: ', e);
+                    }
+                }
+                resolve(result);
+            });
+        }).then((x) => {
+            // update loaded tokens
+            if (useMemoryCache) {
+                loadedToken = {
+                    ...loadedToken,
+                    ...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 loadZoomAccessTokenCache() {
+        const accessTokenCache = {
+            loadCachedToken: async function () {
+                const tokens = await loadTokenFile();
+                const token = tokens.token;
+                // console.log('retrieving access token from file: ', { token });
+                return token;
+            },
+            updateCachedToken: async function (accessToken) {
+                const tokenFile = await loadTokenFile();
+                if (tokenFile) {
+                    tokenFile.token = accessToken;
+                }
+                // console.log('updating access token in file: ', { accessToken });
+                try {
+                    await writeTokenFile(tokenFile);
+                }
+                catch (e) {
+                    console.error('Failed updating access token in file: ', e);
+                }
+            }
+        };
+        return accessTokenCache;
+    }
+    return {
+        loadZoomAccessTokenCache,
+        readTokenFile,
+        writeTokenFile,
+        deleteTokenFile
     };
-    return accessTokenCache;
-  }
-  return {
-    loadZoomAccessTokenCache,
-    readTokenFile,
-    writeTokenFile,
-    deleteTokenFile
-  };
 }
 
 exports.ZoomOAuthApi = class ZoomOAuthApi {
-  config;
-  cacheService;
-  zoomOAuth;
-  get oauthContext() {
-    return this.zoomOAuth.oauthContext;
-  }
-  constructor(config, cacheService) {
-    this.config = config;
-    this.cacheService = cacheService;
-    const accessTokenCache = config.zoomOAuth.accessTokenCache ? config.zoomOAuth.accessTokenCache : cacheService.loadZoomAccessTokenCache();
-    this.zoomOAuth = zoom.zoomOAuthFactory(config.factoryConfig ?? {})({
-      accessTokenCache,
-      ...config.zoomOAuth
-    });
-  }
-  // MARK: Accessors
-  get serverAccessToken() {
-    return zoom.serverAccessToken(this.oauthContext);
-  }
-  get userAccessToken() {
-    return zoom.userAccessToken(this.oauthContext);
-  }
+    config;
+    cacheService;
+    zoomOAuth;
+    get oauthContext() {
+        return this.zoomOAuth.oauthContext;
+    }
+    constructor(config, cacheService) {
+        this.config = config;
+        this.cacheService = cacheService;
+        const accessTokenCache = config.zoomOAuth.accessTokenCache ? config.zoomOAuth.accessTokenCache : cacheService.loadZoomAccessTokenCache();
+        this.zoomOAuth = zoom.zoomOAuthFactory(config.factoryConfig ?? {})({
+            accessTokenCache,
+            ...config.zoomOAuth
+        });
+    }
+    // MARK: Accessors
+    get serverAccessToken() {
+        return zoom.serverAccessToken(this.oauthContext);
+    }
+    get userAccessToken() {
+        return zoom.userAccessToken(this.oauthContext);
+    }
 };
-exports.ZoomOAuthApi = __decorate([common.Injectable(), __param(0, common.Inject(ZoomOAuthServiceConfig)), __param(1, common.Inject(exports.ZoomOAuthAccessTokenCacheService)), __metadata("design:paramtypes", [ZoomOAuthServiceConfig, exports.ZoomOAuthAccessTokenCacheService])], exports.ZoomOAuthApi);
+exports.ZoomOAuthApi = __decorate([
+    common.Injectable(),
+    __param(0, common.Inject(ZoomOAuthServiceConfig)),
+    __param(1, common.Inject(exports.ZoomOAuthAccessTokenCacheService)),
+    __metadata("design:paramtypes", [ZoomOAuthServiceConfig,
+        exports.ZoomOAuthAccessTokenCacheService])
+], exports.ZoomOAuthApi);
 
 function zoomOAuthServiceConfigFactory(configService) {
-  const config = readZoomOAuthServiceConfigFromConfigService(configService);
-  return config;
+    const config = readZoomOAuthServiceConfigFromConfigService(configService);
+    return config;
 }
 /**
  * Convenience function used to generate ModuleMetadata for an app's ZoomOAuthModule.
@@ -337,22 +351,21 @@ function zoomOAuthServiceConfigFactory(configService) {
  * @returns
  */
 function appZoomOAuthModuleMetadata(config$1) {
-  const {
-    dependencyModule,
-    imports,
-    exports: exports$1,
-    providers
-  } = config$1;
-  const dependencyModuleImport = dependencyModule ? [dependencyModule] : [];
-  return {
-    imports: [config.ConfigModule, ...dependencyModuleImport, ...(imports ?? [])],
-    exports: [exports.ZoomOAuthApi, ...(exports$1 ?? [])],
-    providers: [{
-      provide: ZoomOAuthServiceConfig,
-      inject: [config.ConfigService],
-      useFactory: config$1.zoomOAuthServiceConfigFactory ?? zoomOAuthServiceConfigFactory
-    }, exports.ZoomOAuthApi, ...(providers ?? [])]
-  };
+    const { dependencyModule, imports, exports: exports$1, providers } = config$1;
+    const dependencyModuleImport = dependencyModule ? [dependencyModule] : [];
+    return {
+        imports: [config.ConfigModule, ...dependencyModuleImport, ...(imports ?? [])],
+        exports: [exports.ZoomOAuthApi, ...(exports$1 ?? [])],
+        providers: [
+            {
+                provide: ZoomOAuthServiceConfig,
+                inject: [config.ConfigService],
+                useFactory: config$1.zoomOAuthServiceConfigFactory ?? zoomOAuthServiceConfigFactory
+            },
+            exports.ZoomOAuthApi,
+            ...(providers ?? [])
+        ]
+    };
 }
 
 const ZOOM_SECRET_TOKEN_ENV_VAR = 'ZOOM_SECRET_TOKEN';
@@ -360,12 +373,12 @@ const ZOOM_SECRET_TOKEN_ENV_VAR = 'ZOOM_SECRET_TOKEN';
  * Configuration for ZoomService
  */
 class ZoomWebhookServiceConfig {
-  webhookConfig;
-  static assertValidConfig(config) {
-    if (!config.webhookConfig.zoomSecretToken) {
-      throw new Error('No zoom secret token specified.');
+    webhookConfig;
+    static assertValidConfig(config) {
+        if (!config.webhookConfig.zoomSecretToken) {
+            throw new Error('No zoom secret token specified.');
+        }
     }
-  }
 }
 
 // MARK: Meeting Alert
@@ -390,29 +403,29 @@ const ZOOM_WEBHOOK_MEETING_PERMANENTLY_DELETED_EVENT_TYPE = 'meeting.permanently
  * @returns
  */
 function zoomWebhookEvent(event) {
-  return {
-    event: event.event,
-    event_ts: event.event_ts,
-    payload: event.payload
-  };
+    return {
+        event: event.event,
+        event_ts: event.event_ts,
+        payload: event.payload
+    };
 }
-const zoomEventHandlerFactory = util.handlerFactory(x => x.event);
+const zoomEventHandlerFactory = util.handlerFactory((x) => x.event);
 const zoomEventHandlerConfigurerFactory = util.handlerConfigurerFactory({
-  configurerForAccessor: accessor => {
-    // eslint-disable-next-line
-    const fnWithKey = util.handlerMappedSetFunctionFactory(accessor, zoomWebhookEvent);
-    const configurer = {
-      ...accessor,
-      // Meetings
-      handleMeetingCreated: fnWithKey(ZOOM_WEBHOOK_MEETING_CREATED_EVENT_TYPE),
-      handleMeetingUpdated: fnWithKey(ZOOM_WEBHOOK_MEETING_UPDATED_EVENT_TYPE),
-      handleMeetingDeleted: fnWithKey(ZOOM_WEBHOOK_MEETING_DELETED_EVENT_TYPE),
-      handleMeetingStarted: fnWithKey(ZOOM_WEBHOOK_MEETING_STARTED_EVENT_TYPE),
-      handleMeetingEnded: fnWithKey(ZOOM_WEBHOOK_MEETING_ENDED_EVENT_TYPE),
-      handleMeetingPermanentlyDeleted: fnWithKey(ZOOM_WEBHOOK_MEETING_PERMANENTLY_DELETED_EVENT_TYPE)
-    };
-    return configurer;
-  }
+    configurerForAccessor: (accessor) => {
+        // eslint-disable-next-line
+        const fnWithKey = util.handlerMappedSetFunctionFactory(accessor, zoomWebhookEvent);
+        const configurer = {
+            ...accessor,
+            // Meetings
+            handleMeetingCreated: fnWithKey(ZOOM_WEBHOOK_MEETING_CREATED_EVENT_TYPE),
+            handleMeetingUpdated: fnWithKey(ZOOM_WEBHOOK_MEETING_UPDATED_EVENT_TYPE),
+            handleMeetingDeleted: fnWithKey(ZOOM_WEBHOOK_MEETING_DELETED_EVENT_TYPE),
+            handleMeetingStarted: fnWithKey(ZOOM_WEBHOOK_MEETING_STARTED_EVENT_TYPE),
+            handleMeetingEnded: fnWithKey(ZOOM_WEBHOOK_MEETING_ENDED_EVENT_TYPE),
+            handleMeetingPermanentlyDeleted: fnWithKey(ZOOM_WEBHOOK_MEETING_PERMANENTLY_DELETED_EVENT_TYPE)
+        };
+        return configurer;
+    }
 });
 
 /**
@@ -424,18 +437,18 @@ const zoomEventHandlerConfigurerFactory = util.handlerConfigurerFactory({
  * @returns A function that verifies a Zoom webhook event.
  */
 function zoomWebhookEventVerifier(zoomSecretToken) {
-  return (request, rawBody) => {
-    const requestBodyString = String(request.body);
-    const message = `v0:${request.headers['x-zm-request-timestamp']}:${requestBodyString}`;
-    const hashForVerify = crypto.createHmac('sha256', zoomSecretToken).update(message).digest('hex');
-    const signature = `v0=${hashForVerify}`;
-    const valid = request.headers['x-zm-signature'] === signature;
-    const result = {
-      valid,
-      event: JSON.parse(requestBodyString)
+    return (request, rawBody) => {
+        const requestBodyString = String(request.body);
+        const message = `v0:${request.headers['x-zm-request-timestamp']}:${requestBodyString}`;
+        const hashForVerify = crypto.createHmac('sha256', zoomSecretToken).update(message).digest('hex');
+        const signature = `v0=${hashForVerify}`;
+        const valid = request.headers['x-zm-signature'] === signature;
+        const result = {
+            valid,
+            event: JSON.parse(requestBodyString)
+        };
+        return result;
     };
-    return result;
-  };
 }
 
 const ZOOM_WEBHOOK_URL_VALIDATION_EVENT_TYPE = 'endpoint.url_validation';
@@ -447,193 +460,216 @@ const ZOOM_WEBHOOK_URL_VALIDATION_EVENT_TYPE = 'endpoint.url_validation';
  * @returns A ZoomWebhookEventValidationFunction.
  */
 function zoomWebhookEventValidationFunction(zoomSecretToken) {
-  return event => {
-    const {
-      plainToken
-    } = event.payload;
-    if (!plainToken) {
-      throw new Error(`The expected plaintoken value was not provided by the event's payload.`);
-    }
-    const encryptedToken = crypto.createHmac('sha256', zoomSecretToken).update(plainToken).digest('hex');
-    const result = {
-      plainToken,
-      encryptedToken
+    return (event) => {
+        const { plainToken } = event.payload;
+        if (!plainToken) {
+            throw new Error(`The expected plaintoken value was not provided by the event's payload.`);
+        }
+        const encryptedToken = crypto.createHmac('sha256', zoomSecretToken).update(plainToken).digest('hex');
+        const result = {
+            plainToken,
+            encryptedToken
+        };
+        return result;
     };
-    return result;
-  };
 }
 
 /**
  * Service that makes system changes based on Zoom webhook events.
  */
 exports.ZoomWebhookService = class ZoomWebhookService {
-  logger = new common.Logger('ZoomWebhookService');
-  _verifier;
-  _validator;
-  handler = zoomEventHandlerFactory();
-  configure = zoomEventHandlerConfigurerFactory(this.handler);
-  constructor(config) {
-    this._verifier = zoomWebhookEventVerifier(config.webhookConfig.zoomSecretToken);
-    this._validator = zoomWebhookEventValidationFunction(config.webhookConfig.zoomSecretToken);
-  }
-  async updateForWebhook(req, rawBody) {
-    const {
-      valid,
-      event
-    } = this._verifier(req, rawBody);
-    let handled = false;
-    let validationEventResponse;
-    if (!valid) {
-      this.logger.warn('Received invalid zoom event: ', event);
-    } else if (event.event === ZOOM_WEBHOOK_URL_VALIDATION_EVENT_TYPE) {
-      validationEventResponse = this._validator(event);
-      handled = true;
-    } else {
-      handled = await this.updateForZoomEvent(event);
-    }
-    const result = {
-      valid,
-      handled,
-      event,
-      validationEventResponse
-    };
-    return result;
-  }
-  async updateForZoomEvent(event) {
-    const handled = await this.handler(event);
-    if (!handled) {
-      this.logger.warn('Received unexpected/unhandled zoom event: ', event);
-    }
-    return handled;
-  }
+    logger = new common.Logger('ZoomWebhookService');
+    _verifier;
+    _validator;
+    handler = zoomEventHandlerFactory();
+    configure = zoomEventHandlerConfigurerFactory(this.handler);
+    constructor(config) {
+        this._verifier = zoomWebhookEventVerifier(config.webhookConfig.zoomSecretToken);
+        this._validator = zoomWebhookEventValidationFunction(config.webhookConfig.zoomSecretToken);
+    }
+    async updateForWebhook(req, rawBody) {
+        const { valid, event } = this._verifier(req, rawBody);
+        let handled = false;
+        let validationEventResponse;
+        if (!valid) {
+            this.logger.warn('Received invalid zoom event: ', event);
+        }
+        else if (event.event === ZOOM_WEBHOOK_URL_VALIDATION_EVENT_TYPE) {
+            validationEventResponse = this._validator(event);
+            handled = true;
+        }
+        else {
+            handled = await this.updateForZoomEvent(event);
+        }
+        const result = {
+            valid,
+            handled,
+            event,
+            validationEventResponse
+        };
+        return result;
+    }
+    async updateForZoomEvent(event) {
+        const handled = await this.handler(event);
+        if (!handled) {
+            this.logger.warn('Received unexpected/unhandled zoom event: ', event);
+        }
+        return handled;
+    }
 };
-exports.ZoomWebhookService = __decorate([common.Injectable(), __param(0, common.Inject(ZoomWebhookServiceConfig)), __metadata("design:paramtypes", [ZoomWebhookServiceConfig])], exports.ZoomWebhookService);
+exports.ZoomWebhookService = __decorate([
+    common.Injectable(),
+    __param(0, common.Inject(ZoomWebhookServiceConfig)),
+    __metadata("design:paramtypes", [ZoomWebhookServiceConfig])
+], exports.ZoomWebhookService);
 
 exports.ZoomWebhookController = class ZoomWebhookController {
-  zoomWebhookService;
-  constructor(zoomWebhookService) {
-    this.zoomWebhookService = zoomWebhookService;
-  }
-  async handleZoomWebhook(res, req, rawBody) {
-    const {
-      valid,
-      validationEventResponse
-    } = await this.zoomWebhookService.updateForWebhook(req, rawBody);
-    const response = res.status(200); // always return a 200 status code
-    if (valid && validationEventResponse) {
-      response.json(validationEventResponse);
-    } else {
-      response.json({});
-    }
-  }
+    zoomWebhookService;
+    constructor(zoomWebhookService) {
+        this.zoomWebhookService = zoomWebhookService;
+    }
+    async handleZoomWebhook(res, req, rawBody) {
+        const { valid, validationEventResponse } = await this.zoomWebhookService.updateForWebhook(req, rawBody);
+        const response = res.status(200); // always return a 200 status code
+        if (valid && validationEventResponse) {
+            response.json(validationEventResponse);
+        }
+        else {
+            response.json({});
+        }
+    }
 };
-__decorate([common.Post(), __param(0, common.Res()), __param(1, common.Req()), __param(2, nestjs.RawBody()), __metadata("design:type", Function), __metadata("design:paramtypes", [Object, Object, Object]), __metadata("design:returntype", Promise)], exports.ZoomWebhookController.prototype, "handleZoomWebhook", null);
-exports.ZoomWebhookController = __decorate([common.Controller('/webhook/zoom'), __param(0, common.Inject(exports.ZoomWebhookService)), __metadata("design:paramtypes", [exports.ZoomWebhookService])], exports.ZoomWebhookController);
+__decorate([
+    common.Post(),
+    __param(0, common.Res()),
+    __param(1, common.Req()),
+    __param(2, nestjs.RawBody()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], exports.ZoomWebhookController.prototype, "handleZoomWebhook", null);
+exports.ZoomWebhookController = __decorate([
+    common.Controller('/webhook/zoom'),
+    __param(0, common.Inject(exports.ZoomWebhookService)),
+    __metadata("design:paramtypes", [exports.ZoomWebhookService])
+], exports.ZoomWebhookController);
 
 function zoomWebhookServiceConfigFactory(configService) {
-  const config = {
-    webhookConfig: {
-      zoomSecretToken: configService.get(ZOOM_SECRET_TOKEN_ENV_VAR)
-    }
-  };
-  ZoomWebhookServiceConfig.assertValidConfig(config);
-  return config;
+    const config = {
+        webhookConfig: {
+            zoomSecretToken: configService.get(ZOOM_SECRET_TOKEN_ENV_VAR)
+        }
+    };
+    ZoomWebhookServiceConfig.assertValidConfig(config);
+    return config;
 }
 /**
  * Configures webhooks for the service.
  */
-exports.ZoomWebhookModule = class ZoomWebhookModule {};
-exports.ZoomWebhookModule = __decorate([common.Module({
-  imports: [config.ConfigModule],
-  controllers: [exports.ZoomWebhookController],
-  exports: [exports.ZoomWebhookService],
-  providers: [{
-    provide: ZoomWebhookServiceConfig,
-    inject: [config.ConfigService],
-    useFactory: zoomWebhookServiceConfigFactory
-  }, exports.ZoomWebhookService]
-})], exports.ZoomWebhookModule);
+exports.ZoomWebhookModule = class ZoomWebhookModule {
+};
+exports.ZoomWebhookModule = __decorate([
+    common.Module({
+        imports: [config.ConfigModule],
+        controllers: [exports.ZoomWebhookController],
+        exports: [exports.ZoomWebhookService],
+        providers: [
+            {
+                provide: ZoomWebhookServiceConfig,
+                inject: [config.ConfigService],
+                useFactory: zoomWebhookServiceConfigFactory
+            },
+            exports.ZoomWebhookService
+        ]
+    })
+], exports.ZoomWebhookModule);
 
 /**
  * Configuration for ZoomService
  */
 class ZoomServiceConfig {
-  zoom;
-  factoryConfig;
-  static assertValidConfig(config) {
-    // TODO?
-  }
+    zoom;
+    factoryConfig;
+    static assertValidConfig(config) {
+        // TODO?
+    }
 }
 
 exports.ZoomApi = class ZoomApi {
-  config;
-  zoomOAuthApi;
-  zoom;
-  get zoomContext() {
-    return this.zoom.zoomServerContext;
-  }
-  get zoomRateLimiter() {
-    return this.zoom.zoomServerContext.zoomRateLimiter;
-  }
-  constructor(config, zoomOAuthApi) {
-    this.config = config;
-    this.zoomOAuthApi = zoomOAuthApi;
-    this.zoom = zoom.zoomFactory({
-      ...config.factoryConfig,
-      oauthContext: zoomOAuthApi.oauthContext
-    })(config.zoom);
-  }
-  // MARK: Users
-  get getUser() {
-    return zoom.getUser(this.zoomContext);
-  }
-  get listUsers() {
-    return zoom.listUsers(this.zoomContext);
-  }
-  get listUsersPageFactory() {
-    return zoom.listUsersPageFactory(this.zoomContext);
-  }
-  // MARK: Meetings
-  get listMeetingsForUser() {
-    return zoom.listMeetingsForUser(this.zoomContext);
-  }
-  get listMeetingsForUserPageFactory() {
-    return zoom.listMeetingsForUserPageFactory(this.zoomContext);
-  }
-  get createMeetingForUser() {
-    return zoom.createMeetingForUser(this.zoomContext);
-  }
-  get getMeeting() {
-    return zoom.getMeeting(this.zoomContext);
-  }
-  get updateMeeting() {
-    return zoom.updateMeeting(this.zoomContext);
-  }
-  get deleteMeeting() {
-    return zoom.deleteMeeting(this.zoomContext);
-  }
-  // MARK: Past Meetings
-  get getPastMeeting() {
-    return zoom.getPastMeeting(this.zoomContext);
-  }
-  get getPastMeetingParticipants() {
-    return zoom.getPastMeetingParticipants(this.zoomContext);
-  }
+    config;
+    zoomOAuthApi;
+    zoom;
+    get zoomContext() {
+        return this.zoom.zoomServerContext;
+    }
+    get zoomRateLimiter() {
+        return this.zoom.zoomServerContext.zoomRateLimiter;
+    }
+    constructor(config, zoomOAuthApi) {
+        this.config = config;
+        this.zoomOAuthApi = zoomOAuthApi;
+        this.zoom = zoom.zoomFactory({
+            ...config.factoryConfig,
+            oauthContext: zoomOAuthApi.oauthContext
+        })(config.zoom);
+    }
+    // MARK: Users
+    get getUser() {
+        return zoom.getUser(this.zoomContext);
+    }
+    get listUsers() {
+        return zoom.listUsers(this.zoomContext);
+    }
+    get listUsersPageFactory() {
+        return zoom.listUsersPageFactory(this.zoomContext);
+    }
+    // MARK: Meetings
+    get listMeetingsForUser() {
+        return zoom.listMeetingsForUser(this.zoomContext);
+    }
+    get listMeetingsForUserPageFactory() {
+        return zoom.listMeetingsForUserPageFactory(this.zoomContext);
+    }
+    get createMeetingForUser() {
+        return zoom.createMeetingForUser(this.zoomContext);
+    }
+    get getMeeting() {
+        return zoom.getMeeting(this.zoomContext);
+    }
+    get updateMeeting() {
+        return zoom.updateMeeting(this.zoomContext);
+    }
+    get deleteMeeting() {
+        return zoom.deleteMeeting(this.zoomContext);
+    }
+    // MARK: Past Meetings
+    get getPastMeeting() {
+        return zoom.getPastMeeting(this.zoomContext);
+    }
+    get getPastMeetingParticipants() {
+        return zoom.getPastMeetingParticipants(this.zoomContext);
+    }
 };
-exports.ZoomApi = __decorate([common.Injectable(), __param(0, common.Inject(ZoomServiceConfig)), __param(1, common.Inject(exports.ZoomOAuthApi)), __metadata("design:paramtypes", [ZoomServiceConfig, exports.ZoomOAuthApi])], exports.ZoomApi);
+exports.ZoomApi = __decorate([
+    common.Injectable(),
+    __param(0, common.Inject(ZoomServiceConfig)),
+    __param(1, common.Inject(exports.ZoomOAuthApi)),
+    __metadata("design:paramtypes", [ZoomServiceConfig,
+        exports.ZoomOAuthApi])
+], exports.ZoomApi);
 class ZoomApiUserContext {
-  constructor(refreshToken) {
-    // TODO: ...
-  }
+    constructor(refreshToken) {
+        // TODO: ...
+    }
 }
 
 // MARK: Provider Factories
 function zoomServiceConfigFactory(configService) {
-  const config = {
-    zoom: {}
-  };
-  ZoomServiceConfig.assertValidConfig(config);
-  return config;
+    const config = {
+        zoom: {}
+    };
+    ZoomServiceConfig.assertValidConfig(config);
+    return config;
 }
 /**
  * Convenience function used to generate ModuleMetadata for an app's ZoomModule.
@@ -643,22 +679,21 @@ function zoomServiceConfigFactory(configService) {
  * @returns
  */
 function appZoomModuleMetadata(config$1) {
-  const {
-    dependencyModule,
-    imports,
-    exports: exports$1,
-    providers
-  } = config$1;
-  const dependencyModuleImport = dependencyModule ? [dependencyModule] : [];
-  return {
-    imports: [config.ConfigModule, ...dependencyModuleImport, ...(imports ?? [])],
-    exports: [exports.ZoomApi, ...(exports$1 ?? [])],
-    providers: [{
-      provide: ZoomServiceConfig,
-      inject: [config.ConfigService],
-      useFactory: zoomServiceConfigFactory
-    }, exports.ZoomApi, ...(providers ?? [])]
-  };
+    const { dependencyModule, imports, exports: exports$1, providers } = config$1;
+    const dependencyModuleImport = dependencyModule ? [dependencyModule] : [];
+    return {
+        imports: [config.ConfigModule, ...dependencyModuleImport, ...(imports ?? [])],
+        exports: [exports.ZoomApi, ...(exports$1 ?? [])],
+        providers: [
+            {
+                provide: ZoomServiceConfig,
+                inject: [config.ConfigService],
+                useFactory: zoomServiceConfigFactory
+            },
+            exports.ZoomApi,
+            ...(providers ?? [])
+        ]
+    };
 }
 
 exports.DEFAULT_FILE_ZOOM_ACCOUNTS_ACCESS_TOKEN_CACHE_SERVICE_PATH = DEFAULT_FILE_ZOOM_ACCOUNTS_ACCESS_TOKEN_CACHE_SERVICE_PATH;