@dereekb/zoom 12.6.21 → 13.0.0

package/nestjs/index.cjs.js

@@ -0,0 +1,692 @@
+'use strict';
+
+var common = require('@nestjs/common');
+var zoom = require('@dereekb/zoom');
+var util = require('@dereekb/util');
+var path = require('path');
+var fs = require('fs');
+var config = require('@nestjs/config');
+var nestjs = require('@dereekb/nestjs');
+var crypto = require('crypto');
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+function __param(paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+}
+
+function __metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+/**
+ * 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');
+      }
+    }
+  }
+}
+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;
+}
+
+/**
+ * Service used for retrieving ZoomAccessTokenCache for Zoom services.
+ */
+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}`);
+  });
+}
+/**
+ * Merges the input services in order to use some as a backup source.
+ *
+ * If once source fails retrieval, the next will be tried.
+ *
+ * When updating a cached token, it will update the token across all services.
+ *
+ * @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);
+            }
+          }
+        });
+      }
+    };
+    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;
+}
+// MARK: Memory Access Token Cache
+/**
+ * Creates a ZoomOAuthAccessTokenCacheService that uses in-memory storage.
+ *
+ * @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
+          });
+        }
+      }
+    };
+    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';
+/**
+ * Creates a ZoomOAuthAccessTokenCacheService that reads and writes the access token to the file system.
+ *
+ * Useful for testing.
+ *
+ * @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);
+        }
+      });
+    });
+  }
+  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
+  };
+}
+
+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);
+  }
+};
+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;
+}
+/**
+ * Convenience function used to generate ModuleMetadata for an app's ZoomOAuthModule.
+ *
+ * @param provide
+ * @param useFactory
+ * @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 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.');
+    }
+  }
+}
+
+// MARK: Meeting Alert
+const ZOOM_WEBHOOK_MEETING_ALERT_EVENT_TYPE = 'meeting.alert';
+// MARK: Meeting Created
+const ZOOM_WEBHOOK_MEETING_CREATED_EVENT_TYPE = 'meeting.created';
+// MARK: Meeting Updated
+const ZOOM_WEBHOOK_MEETING_UPDATED_EVENT_TYPE = 'meeting.updated';
+// MARK: Meeting Deleted
+const ZOOM_WEBHOOK_MEETING_DELETED_EVENT_TYPE = 'meeting.deleted';
+// MARK: Meeting Started
+const ZOOM_WEBHOOK_MEETING_STARTED_EVENT_TYPE = 'meeting.started';
+// MARK: Meeting Ended
+const ZOOM_WEBHOOK_MEETING_ENDED_EVENT_TYPE = 'meeting.ended';
+// MARK: Meeting Permanently Deleted
+const ZOOM_WEBHOOK_MEETING_PERMANENTLY_DELETED_EVENT_TYPE = 'meeting.permanently_deleted';
+
+/**
+ * Creates a ZoomWebhookEvent and treats the data as the input type.
+ *
+ * @param event
+ * @returns
+ */
+function zoomWebhookEvent(event) {
+  return {
+    event: event.event,
+    event_ts: event.event_ts,
+    payload: event.payload
+  };
+}
+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;
+  }
+});
+
+/**
+ * Verifies a Zoom webhook event header.
+ *
+ * @see https://developers.zoom.us/docs/api/webhooks/#verify-with-zooms-header
+ *
+ * @param zoomSecretToken The Zoom secret token.
+ * @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 result;
+  };
+}
+
+const ZOOM_WEBHOOK_URL_VALIDATION_EVENT_TYPE = 'endpoint.url_validation';
+
+/**
+ * Creates a ZoomWebhookEventValidationFunction.
+ *
+ * @param zoomSecretToken The secret token used to validate the event.
+ * @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 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;
+  }
+};
+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({});
+    }
+  }
+};
+__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;
+}
+/**
+ * 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);
+
+/**
+ * Configuration for ZoomService
+ */
+class ZoomServiceConfig {
+  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);
+  }
+};
+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: ...
+  }
+}
+
+// MARK: Provider Factories
+function zoomServiceConfigFactory(configService) {
+  const config = {
+    zoom: {}
+  };
+  ZoomServiceConfig.assertValidConfig(config);
+  return config;
+}
+/**
+ * Convenience function used to generate ModuleMetadata for an app's ZoomModule.
+ *
+ * @param provide
+ * @param useFactory
+ * @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 ?? [])]
+  };
+}
+
+exports.DEFAULT_FILE_ZOOM_ACCOUNTS_ACCESS_TOKEN_CACHE_SERVICE_PATH = DEFAULT_FILE_ZOOM_ACCOUNTS_ACCESS_TOKEN_CACHE_SERVICE_PATH;
+exports.ZOOM_SECRET_TOKEN_ENV_VAR = ZOOM_SECRET_TOKEN_ENV_VAR;
+exports.ZOOM_WEBHOOK_MEETING_ALERT_EVENT_TYPE = ZOOM_WEBHOOK_MEETING_ALERT_EVENT_TYPE;
+exports.ZOOM_WEBHOOK_MEETING_CREATED_EVENT_TYPE = ZOOM_WEBHOOK_MEETING_CREATED_EVENT_TYPE;
+exports.ZOOM_WEBHOOK_MEETING_DELETED_EVENT_TYPE = ZOOM_WEBHOOK_MEETING_DELETED_EVENT_TYPE;
+exports.ZOOM_WEBHOOK_MEETING_ENDED_EVENT_TYPE = ZOOM_WEBHOOK_MEETING_ENDED_EVENT_TYPE;
+exports.ZOOM_WEBHOOK_MEETING_PERMANENTLY_DELETED_EVENT_TYPE = ZOOM_WEBHOOK_MEETING_PERMANENTLY_DELETED_EVENT_TYPE;
+exports.ZOOM_WEBHOOK_MEETING_STARTED_EVENT_TYPE = ZOOM_WEBHOOK_MEETING_STARTED_EVENT_TYPE;
+exports.ZOOM_WEBHOOK_MEETING_UPDATED_EVENT_TYPE = ZOOM_WEBHOOK_MEETING_UPDATED_EVENT_TYPE;
+exports.ZOOM_WEBHOOK_URL_VALIDATION_EVENT_TYPE = ZOOM_WEBHOOK_URL_VALIDATION_EVENT_TYPE;
+exports.ZoomApiUserContext = ZoomApiUserContext;
+exports.ZoomOAuthServiceConfig = ZoomOAuthServiceConfig;
+exports.ZoomServiceConfig = ZoomServiceConfig;
+exports.ZoomWebhookServiceConfig = ZoomWebhookServiceConfig;
+exports.appZoomModuleMetadata = appZoomModuleMetadata;
+exports.appZoomOAuthModuleMetadata = appZoomOAuthModuleMetadata;
+exports.fileZoomOAuthAccessTokenCacheService = fileZoomOAuthAccessTokenCacheService;
+exports.logMergeZoomOAuthAccessTokenCacheServiceErrorFunction = logMergeZoomOAuthAccessTokenCacheServiceErrorFunction;
+exports.memoryZoomOAuthAccessTokenCacheService = memoryZoomOAuthAccessTokenCacheService;
+exports.mergeZoomOAuthAccessTokenCacheServices = mergeZoomOAuthAccessTokenCacheServices;
+exports.readZoomOAuthServiceConfigFromConfigService = readZoomOAuthServiceConfigFromConfigService;
+exports.zoomEventHandlerConfigurerFactory = zoomEventHandlerConfigurerFactory;
+exports.zoomEventHandlerFactory = zoomEventHandlerFactory;
+exports.zoomOAuthServiceConfigFactory = zoomOAuthServiceConfigFactory;
+exports.zoomServiceConfigFactory = zoomServiceConfigFactory;
+exports.zoomWebhookEvent = zoomWebhookEvent;
+exports.zoomWebhookEventValidationFunction = zoomWebhookEventValidationFunction;
+exports.zoomWebhookEventVerifier = zoomWebhookEventVerifier;
+exports.zoomWebhookServiceConfigFactory = zoomWebhookServiceConfigFactory;