@dereekb/zoom 13.2.2 → 13.3.0

package/nestjs/index.esm.js

@@ -2,100 +2,346 @@ import { Injectable, Inject, Logger, Post, Res, Req, Controller, Module } from '
 import { zoomOAuthFactory, serverAccessToken, userAccessToken, zoomFactory, getUser, listUsers, listUsersPageFactory, listMeetingsForUser, listMeetingsForUserPageFactory, createMeetingForUser, getMeeting, updateMeeting, deleteMeeting, getPastMeeting, getPastMeetingParticipants } from '@dereekb/zoom';
 import { characterPrefixSuffixInstance, tryWithPromiseFactoriesFunction, isPast, filterMaybeArrayValues, handlerFactory, handlerConfigurerFactory, handlerMappedSetFunctionFactory } from '@dereekb/util';
 import { dirname } from 'path';
-import { rm, writeFile, mkdirSync, readFile } from 'fs';
+import { mkdirSync, readFile, writeFile, rm } from 'fs';
 import { ConfigService, ConfigModule } from '@nestjs/config';
 import { RawBody } from '@dereekb/nestjs';
 import { createHmac } from '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); }
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+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 === "undefined" ? "undefined" : _type_of(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);
+    };
+}
+typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
+function _class_call_check$8(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties$6(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class$6(Constructor, protoProps, staticProps) {
+    if (staticProps) _defineProperties$6(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property$8(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
 /**
  * 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');
+ */ var ZoomOAuthServiceConfig = /*#__PURE__*/ function() {
+    function ZoomOAuthServiceConfig() {
+        _class_call_check$8(this, ZoomOAuthServiceConfig);
+        _define_property$8(this, "zoomOAuth", void 0);
+        _define_property$8(this, "factoryConfig", void 0);
+    }
+    _create_class$6(ZoomOAuthServiceConfig, null, [
+        {
+            key: "assertValidConfig",
+            value: function assertValidConfig(config) {
+                var zoomOAuth = config.zoomOAuth;
+                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');
+                    }
+                }
             }
         }
-    }
-}
+    ]);
+    return ZoomOAuthServiceConfig;
+}();
 function readZoomOAuthServiceConfigFromConfigService(configService, prefix) {
-    const prefixString = 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 = {
+    var prefixString = characterPrefixSuffixInstance({
+        suffix: '_',
+        suffixEmptyString: false
+    }).prefixSuffixString(prefix !== null && prefix !== void 0 ? prefix : '');
+    var accountIdKey = "".concat(prefixString, "ZOOM_ACCOUNT_ID");
+    var clientIdKey = "".concat(prefixString, "ZOOM_CLIENT_ID");
+    var clientSecretKey = "".concat(prefixString, "ZOOM_CLIENT_SECRET");
+    var accountId = configService.getOrThrow(accountIdKey);
+    var clientId = configService.getOrThrow(clientIdKey);
+    var clientSecret = configService.getOrThrow(clientSecretKey);
+    var config = {
         zoomOAuth: {
             authEntityType: 'account',
-            accountId,
-            clientId,
-            clientSecret
+            accountId: accountId,
+            clientId: clientId,
+            clientSecret: clientSecret
         }
     };
     ZoomOAuthServiceConfig.assertValidConfig(config);
     return config;
 }
 
+function _array_like_to_array$2(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _array_without_holes$2(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$2(arr);
+}
+function asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$2(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _class_call_check$7(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _define_property$7(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterable_to_array$2(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _non_iterable_spread$2() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread$3(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$7(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array$2(arr, i) || _non_iterable_rest();
+}
+function _to_consumable_array$2(arr) {
+    return _array_without_holes$2(arr) || _iterable_to_array$2(arr) || _unsupported_iterable_to_array$2(arr) || _non_iterable_spread$2();
+}
+function _unsupported_iterable_to_array$2(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$2(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$2(o, minLen);
+}
+function _ts_generator$2(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
 /**
  * Service used for retrieving ZoomAccessTokenCache for Zoom services.
- */
-let ZoomOAuthAccessTokenCacheService = class ZoomOAuthAccessTokenCacheService {
+ */ var ZoomOAuthAccessTokenCacheService = function ZoomOAuthAccessTokenCacheService() {
+    _class_call_check$7(this, ZoomOAuthAccessTokenCacheService);
 };
 ZoomOAuthAccessTokenCacheService = __decorate([
     Injectable()
 ], 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 ".concat(failedUpdates.length, " caches."));
+    failedUpdates.forEach(function(param, i) {
+        var _param = _sliced_to_array(param, 2); _param[0]; var e = _param[1];
+        console.warn("Cache update failure ".concat(i + 1, ": - ").concat(e));
     });
 }
 /**
@@ -106,62 +352,83 @@ function logMergeZoomOAuthAccessTokenCacheServiceErrorFunction(failedUpdates) {
  * 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;
+ */ function mergeZoomOAuthAccessTokenCacheServices(inputServicesToMerge, logError) {
+    var allServices = _to_consumable_array$2(inputServicesToMerge);
+    var 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 = tryWithPromiseFactoriesFunction({
-            promiseFactories: accessCachesForServices.map((x) => () => x
-                .loadCachedToken()
-                .catch(() => null)
-                .then((x) => {
-                let result = undefined;
-                if (x && !isPast(x.expiresAt)) {
-                    result = x; // only return from cache if it is not expired
-                }
-                return result;
-            })),
+    var loadZoomAccessTokenCache = function loadZoomAccessTokenCache(accessCachesForServices) {
+        var loadCachedTokenFromFirstService = tryWithPromiseFactoriesFunction({
+            promiseFactories: accessCachesForServices.map(function(x) {
+                return function() {
+                    return x.loadCachedToken().catch(function() {
+                        return null;
+                    }).then(function(x) {
+                        var result = undefined;
+                        if (x && !isPast(x.expiresAt)) {
+                            result = x; // only return from cache if it is not expired
+                        }
+                        return result;
+                    });
+                };
+            }),
             successOnMaybe: false,
             throwErrors: false
         });
-        const cacheForService = {
-            loadCachedToken: function () {
+        var cacheForService = {
+            loadCachedToken: function loadCachedToken() {
                 return loadCachedTokenFromFirstService();
             },
-            updateCachedToken: async function (accessToken) {
-                return Promise.allSettled(accessCachesForServices.map((x) => x
-                    .updateCachedToken(accessToken)
-                    .then(() => null)
-                    .catch((e) => {
-                    return [x, e];
-                }))).then((x) => {
-                    // only find the failures if we're logging
-                    if (logErrorFunction != null) {
-                        const failedUpdates = filterMaybeArrayValues(x.map((y) => y.value));
-                        if (failedUpdates.length) {
-                            logErrorFunction(failedUpdates);
-                        }
-                    }
-                });
+            updateCachedToken: function updateCachedToken(accessToken) {
+                return _async_to_generator$2(function() {
+                    return _ts_generator$2(this, function(_state) {
+                        return [
+                            2,
+                            Promise.allSettled(accessCachesForServices.map(function(x) {
+                                return x.updateCachedToken(accessToken).then(function() {
+                                    return null;
+                                }).catch(function(e) {
+                                    return [
+                                        x,
+                                        e
+                                    ];
+                                });
+                            })).then(function(x) {
+                                // only find the failures if we're logging
+                                if (logErrorFunction != null) {
+                                    var failedUpdates = filterMaybeArrayValues(x.map(function(y) {
+                                        return 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
+    var allServiceAccessTokenCaches = allServices.map(function(x) {
+        return x.loadZoomAccessTokenCache();
+    });
+    var allServicesWithCacheForRefreshToken = allServices.filter(function(x) {
+        return x.cacheForRefreshToken != null;
+    });
+    var cacheForRefreshToken = allServiceAccessTokenCaches.length > 0 ? function(refreshToken) {
+        var allCaches = allServicesWithCacheForRefreshToken.map(function(x) {
+            return x.cacheForRefreshToken(refreshToken);
+        });
+        return loadZoomAccessTokenCache(allCaches);
+    } : undefined;
+    var service = {
+        loadZoomAccessTokenCache: function loadZoomAccessTokenCache1() {
+            return loadZoomAccessTokenCache(allServiceAccessTokenCaches);
+        },
+        cacheForRefreshToken: cacheForRefreshToken
     };
     return service;
 }
@@ -170,169 +437,356 @@ function mergeZoomOAuthAccessTokenCacheServices(inputServicesToMerge, logError)
  * Creates a ZoomOAuthAccessTokenCacheService that uses in-memory storage.
  *
  * @returns
- */
-function memoryZoomOAuthAccessTokenCacheService(existingToken, logAccessToConsole) {
-    let token = existingToken;
+ */ function memoryZoomOAuthAccessTokenCacheService(existingToken, logAccessToConsole) {
+    var token = existingToken;
     function loadZoomAccessTokenCache() {
-        const accessTokenCache = {
-            loadCachedToken: async function () {
-                if (logAccessToConsole) {
-                    console.log('retrieving access token from memory: ', { token });
-                }
-                return token;
+        var accessTokenCache = {
+            loadCachedToken: function loadCachedToken() {
+                return _async_to_generator$2(function() {
+                    return _ts_generator$2(this, function(_state) {
+                        if (logAccessToConsole) {
+                            console.log('retrieving access token from memory: ', {
+                                token: token
+                            });
+                        }
+                        return [
+                            2,
+                            token
+                        ];
+                    });
+                })();
             },
-            updateCachedToken: async function (accessToken) {
-                token = accessToken;
-                if (logAccessToConsole) {
-                    console.log('updating access token in memory: ', { accessToken });
-                }
+            updateCachedToken: function updateCachedToken(accessToken) {
+                return _async_to_generator$2(function() {
+                    return _ts_generator$2(this, function(_state) {
+                        token = accessToken;
+                        if (logAccessToConsole) {
+                            console.log('updating access token in memory: ', {
+                                accessToken: accessToken
+                            });
+                        }
+                        return [
+                            2
+                        ];
+                    });
+                })();
             }
         };
         return accessTokenCache;
     }
     return {
-        loadZoomAccessTokenCache,
-        cacheForRefreshToken: () => loadZoomAccessTokenCache()
+        loadZoomAccessTokenCache: loadZoomAccessTokenCache,
+        cacheForRefreshToken: function cacheForRefreshToken() {
+            return loadZoomAccessTokenCache();
+        }
     };
 }
 // MARK: File System Access Token Cache
-const DEFAULT_FILE_ZOOM_ACCOUNTS_ACCESS_TOKEN_CACHE_SERVICE_PATH = '.tmp/zoom-access-tokens.json';
+var 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 fileZoomOAuthAccessTokenCacheService() {
+    var filename = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : DEFAULT_FILE_ZOOM_ACCOUNTS_ACCESS_TOKEN_CACHE_SERVICE_PATH, useMemoryCache = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;
+    var loadedToken = null;
+    function loadTokenFile() {
+        return _async_to_generator$2(function() {
+            var token, _ref;
+            return _ts_generator$2(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        token = undefined;
+                        if (!!loadedToken) return [
+                            3,
+                            2
+                        ];
+                        return [
+                            4,
+                            readTokenFile()
+                        ];
+                    case 1:
+                        token = (_ref = _state.sent()) !== null && _ref !== void 0 ? _ref : {};
+                        return [
+                            3,
+                            3
+                        ];
+                    case 2:
+                        token = loadedToken;
+                        _state.label = 3;
+                    case 3:
+                        return [
+                            2,
+                            token
+                        ];
+                }
+            });
+        })();
     }
     function readTokenFile() {
-        return new Promise((resolve) => {
-            mkdirSync(dirname(filename), { recursive: true }); // make the directory first
-            readFile(filename, {}, (x, data) => {
-                let result = undefined;
+        return new Promise(function(resolve) {
+            mkdirSync(dirname(filename), {
+                recursive: true
+            }); // make the directory first
+            readFile(filename, {}, function(x, data) {
+                var result = undefined;
                 if (!x) {
                     try {
                         result = JSON.parse(data.toString());
-                        if (result?.token) {
+                        if (result === null || result === void 0 ? void 0 : result.token) {
                             result.token.expiresAt = new Date(result.token.expiresAt);
                         }
-                    }
-                    catch (e) {
+                    } catch (e) {
                         console.error('Failed reading token file: ', e);
                     }
                 }
                 resolve(result);
             });
-        }).then((x) => {
+        }).then(function(x) {
             // update loaded tokens
             if (useMemoryCache) {
-                loadedToken = {
-                    ...loadedToken,
-                    ...x
-                };
+                loadedToken = _object_spread$3({}, loadedToken, x);
             }
             return x;
         });
     }
-    async function writeTokenFile(tokens) {
-        return new Promise((resolve, reject) => {
-            writeFile(filename, JSON.stringify(tokens), {}, (x) => {
-                if (!x) {
-                    resolve();
-                }
-                else {
-                    reject(x);
-                }
+    function writeTokenFile(tokens) {
+        return _async_to_generator$2(function() {
+            return _ts_generator$2(this, function(_state) {
+                return [
+                    2,
+                    new Promise(function(resolve, reject) {
+                        writeFile(filename, JSON.stringify(tokens), {}, function(x) {
+                            if (!x) {
+                                resolve();
+                            } else {
+                                reject(x);
+                            }
+                        });
+                    })
+                ];
             });
-        });
+        })();
     }
-    async function deleteTokenFile() {
-        return new Promise((resolve, reject) => {
-            rm(filename, (x) => {
-                if (!x) {
-                    resolve();
-                }
-                else {
-                    reject(x);
-                }
+    function deleteTokenFile() {
+        return _async_to_generator$2(function() {
+            return _ts_generator$2(this, function(_state) {
+                return [
+                    2,
+                    new Promise(function(resolve, reject) {
+                        rm(filename, function(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;
+        var accessTokenCache = {
+            loadCachedToken: function loadCachedToken() {
+                return _async_to_generator$2(function() {
+                    var tokens, token;
+                    return _ts_generator$2(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    loadTokenFile()
+                                ];
+                            case 1:
+                                tokens = _state.sent();
+                                token = tokens.token;
+                                // console.log('retrieving access token from file: ', { token });
+                                return [
+                                    2,
+                                    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);
-                }
+            updateCachedToken: function updateCachedToken(accessToken) {
+                return _async_to_generator$2(function() {
+                    var tokenFile, e;
+                    return _ts_generator$2(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    loadTokenFile()
+                                ];
+                            case 1:
+                                tokenFile = _state.sent();
+                                if (tokenFile) {
+                                    tokenFile.token = accessToken;
+                                }
+                                _state.label = 2;
+                            case 2:
+                                _state.trys.push([
+                                    2,
+                                    4,
+                                    ,
+                                    5
+                                ]);
+                                return [
+                                    4,
+                                    writeTokenFile(tokenFile)
+                                ];
+                            case 3:
+                                _state.sent();
+                                return [
+                                    3,
+                                    5
+                                ];
+                            case 4:
+                                e = _state.sent();
+                                console.error('Failed updating access token in file: ', e);
+                                return [
+                                    3,
+                                    5
+                                ];
+                            case 5:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
             }
         };
         return accessTokenCache;
     }
     return {
-        loadZoomAccessTokenCache,
-        readTokenFile,
-        writeTokenFile,
-        deleteTokenFile
+        loadZoomAccessTokenCache: loadZoomAccessTokenCache,
+        readTokenFile: readTokenFile,
+        writeTokenFile: writeTokenFile,
+        deleteTokenFile: deleteTokenFile
     };
 }
 
-let 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 = zoomOAuthFactory(config.factoryConfig ?? {})({
-            accessTokenCache,
-            ...config.zoomOAuth
+function _class_call_check$6(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties$5(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class$5(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$5(Constructor.prototype, protoProps);
+    return Constructor;
+}
+function _define_property$6(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
         });
+    } else {
+        obj[key] = value;
     }
-    // MARK: Accessors
-    get serverAccessToken() {
-        return serverAccessToken(this.oauthContext);
+    return obj;
+}
+function _object_spread$2(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$6(target, key, source[key]);
+        });
     }
-    get userAccessToken() {
-        return userAccessToken(this.oauthContext);
+    return target;
+}
+var ZoomOAuthApi = /*#__PURE__*/ function() {
+    function ZoomOAuthApi(config, cacheService) {
+        _class_call_check$6(this, ZoomOAuthApi);
+        var _config_factoryConfig;
+        _define_property$6(this, "config", void 0);
+        _define_property$6(this, "cacheService", void 0);
+        _define_property$6(this, "zoomOAuth", void 0);
+        this.config = config;
+        this.cacheService = cacheService;
+        var accessTokenCache = config.zoomOAuth.accessTokenCache ? config.zoomOAuth.accessTokenCache : cacheService.loadZoomAccessTokenCache();
+        this.zoomOAuth = zoomOAuthFactory((_config_factoryConfig = config.factoryConfig) !== null && _config_factoryConfig !== void 0 ? _config_factoryConfig : {})(_object_spread$2({
+            accessTokenCache: accessTokenCache
+        }, config.zoomOAuth));
     }
-};
+    _create_class$5(ZoomOAuthApi, [
+        {
+            key: "oauthContext",
+            get: function get() {
+                return this.zoomOAuth.oauthContext;
+            }
+        },
+        {
+            key: "serverAccessToken",
+            get: // MARK: Accessors
+            function get() {
+                return serverAccessToken(this.oauthContext);
+            }
+        },
+        {
+            key: "userAccessToken",
+            get: function get() {
+                return userAccessToken(this.oauthContext);
+            }
+        }
+    ]);
+    return ZoomOAuthApi;
+}();
 ZoomOAuthApi = __decorate([
     Injectable(),
     __param(0, Inject(ZoomOAuthServiceConfig)),
     __param(1, Inject(ZoomOAuthAccessTokenCacheService))
 ], ZoomOAuthApi);
 
+function _array_like_to_array$1(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes$1(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$1(arr);
+}
+function _iterable_to_array$1(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread$1() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array$1(arr) {
+    return _array_without_holes$1(arr) || _iterable_to_array$1(arr) || _unsupported_iterable_to_array$1(arr) || _non_iterable_spread$1();
+}
+function _unsupported_iterable_to_array$1(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$1(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$1(o, minLen);
+}
 function zoomOAuthServiceConfigFactory(configService) {
-    const config = readZoomOAuthServiceConfigFromConfigService(configService);
+    var config = readZoomOAuthServiceConfigFromConfigService(configService);
     return config;
 }
 /**
@@ -341,73 +795,167 @@ function zoomOAuthServiceConfigFactory(configService) {
  * @param provide
  * @param useFactory
  * @returns
- */
-function appZoomOAuthModuleMetadata(config) {
-    const { dependencyModule, imports, exports: exports$1, providers } = config;
-    const dependencyModuleImport = dependencyModule ? [dependencyModule] : [];
+ */ function appZoomOAuthModuleMetadata(config) {
+    var _config_zoomOAuthServiceConfigFactory;
+    var dependencyModule = config.dependencyModule, imports = config.imports, exports$1 = config.exports, providers = config.providers;
+    var dependencyModuleImport = dependencyModule ? [
+        dependencyModule
+    ] : [];
     return {
-        imports: [ConfigModule, ...dependencyModuleImport, ...(imports ?? [])],
-        exports: [ZoomOAuthApi, ...(exports$1 ?? [])],
+        imports: [
+            ConfigModule
+        ].concat(_to_consumable_array$1(dependencyModuleImport), _to_consumable_array$1(imports !== null && imports !== void 0 ? imports : [])),
+        exports: [
+            ZoomOAuthApi
+        ].concat(_to_consumable_array$1(exports$1 !== null && exports$1 !== void 0 ? exports$1 : [])),
         providers: [
             {
                 provide: ZoomOAuthServiceConfig,
-                inject: [ConfigService],
-                useFactory: config.zoomOAuthServiceConfigFactory ?? zoomOAuthServiceConfigFactory
+                inject: [
+                    ConfigService
+                ],
+                useFactory: (_config_zoomOAuthServiceConfigFactory = config.zoomOAuthServiceConfigFactory) !== null && _config_zoomOAuthServiceConfigFactory !== void 0 ? _config_zoomOAuthServiceConfigFactory : zoomOAuthServiceConfigFactory
             },
-            ZoomOAuthApi,
-            ...(providers ?? [])
-        ]
+            ZoomOAuthApi
+        ].concat(_to_consumable_array$1(providers !== null && providers !== void 0 ? providers : []))
     };
 }
 
-const ZOOM_SECRET_TOKEN_ENV_VAR = 'ZOOM_SECRET_TOKEN';
+function _class_call_check$5(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties$4(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class$4(Constructor, protoProps, staticProps) {
+    if (staticProps) _defineProperties$4(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property$5(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+var 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.');
-        }
+ */ var ZoomWebhookServiceConfig = /*#__PURE__*/ function() {
+    function ZoomWebhookServiceConfig() {
+        _class_call_check$5(this, ZoomWebhookServiceConfig);
+        _define_property$5(this, "webhookConfig", void 0);
     }
-}
+    _create_class$4(ZoomWebhookServiceConfig, null, [
+        {
+            key: "assertValidConfig",
+            value: function assertValidConfig(config) {
+                if (!config.webhookConfig.zoomSecretToken) {
+                    throw new Error('No zoom secret token specified.');
+                }
+            }
+        }
+    ]);
+    return ZoomWebhookServiceConfig;
+} 
+();
 
 // MARK: Meeting Alert
-const ZOOM_WEBHOOK_MEETING_ALERT_EVENT_TYPE = 'meeting.alert';
+var ZOOM_WEBHOOK_MEETING_ALERT_EVENT_TYPE = 'meeting.alert';
 // MARK: Meeting Created
-const ZOOM_WEBHOOK_MEETING_CREATED_EVENT_TYPE = 'meeting.created';
+var ZOOM_WEBHOOK_MEETING_CREATED_EVENT_TYPE = 'meeting.created';
 // MARK: Meeting Updated
-const ZOOM_WEBHOOK_MEETING_UPDATED_EVENT_TYPE = 'meeting.updated';
+var ZOOM_WEBHOOK_MEETING_UPDATED_EVENT_TYPE = 'meeting.updated';
 // MARK: Meeting Deleted
-const ZOOM_WEBHOOK_MEETING_DELETED_EVENT_TYPE = 'meeting.deleted';
+var ZOOM_WEBHOOK_MEETING_DELETED_EVENT_TYPE = 'meeting.deleted';
 // MARK: Meeting Started
-const ZOOM_WEBHOOK_MEETING_STARTED_EVENT_TYPE = 'meeting.started';
+var ZOOM_WEBHOOK_MEETING_STARTED_EVENT_TYPE = 'meeting.started';
 // MARK: Meeting Ended
-const ZOOM_WEBHOOK_MEETING_ENDED_EVENT_TYPE = 'meeting.ended';
+var ZOOM_WEBHOOK_MEETING_ENDED_EVENT_TYPE = 'meeting.ended';
 // MARK: Meeting Permanently Deleted
-const ZOOM_WEBHOOK_MEETING_PERMANENTLY_DELETED_EVENT_TYPE = 'meeting.permanently_deleted';
+var ZOOM_WEBHOOK_MEETING_PERMANENTLY_DELETED_EVENT_TYPE = 'meeting.permanently_deleted';
 
+function _define_property$4(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _object_spread$1(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$4(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys$1(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props$1(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys$1(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
 /**
  * Creates a ZoomWebhookEvent and treats the data as the input type.
  *
  * @param event
  * @returns
- */
-function zoomWebhookEvent(event) {
+ */ function zoomWebhookEvent(event) {
     return {
         event: event.event,
         event_ts: event.event_ts,
         payload: event.payload
     };
 }
-const zoomEventHandlerFactory = handlerFactory((x) => x.event);
-const zoomEventHandlerConfigurerFactory = handlerConfigurerFactory({
-    configurerForAccessor: (accessor) => {
+var zoomEventHandlerFactory = handlerFactory(function(x) {
+    return x.event;
+});
+var zoomEventHandlerConfigurerFactory = handlerConfigurerFactory({
+    configurerForAccessor: function configurerForAccessor(accessor) {
         // eslint-disable-next-line
-        const fnWithKey = handlerMappedSetFunctionFactory(accessor, zoomWebhookEvent);
-        const configurer = {
-            ...accessor,
+        var fnWithKey = handlerMappedSetFunctionFactory(accessor, zoomWebhookEvent);
+        var configurer = _object_spread_props$1(_object_spread$1({}, accessor), {
             // Meetings
             handleMeetingCreated: fnWithKey(ZOOM_WEBHOOK_MEETING_CREATED_EVENT_TYPE),
             handleMeetingUpdated: fnWithKey(ZOOM_WEBHOOK_MEETING_UPDATED_EVENT_TYPE),
@@ -415,7 +963,7 @@ const zoomEventHandlerConfigurerFactory = handlerConfigurerFactory({
             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;
     }
 });
@@ -427,109 +975,501 @@ const zoomEventHandlerConfigurerFactory = handlerConfigurerFactory({
  *
  * @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 = createHmac('sha256', zoomSecretToken).update(message).digest('hex');
-        const signature = `v0=${hashForVerify}`;
-        const valid = request.headers['x-zm-signature'] === signature;
-        const result = {
-            valid,
+ */ function zoomWebhookEventVerifier(zoomSecretToken) {
+    return function(request, rawBody) {
+        var requestBodyString = String(request.body);
+        var message = "v0:".concat(request.headers['x-zm-request-timestamp'], ":").concat(requestBodyString);
+        var hashForVerify = createHmac('sha256', zoomSecretToken).update(message).digest('hex');
+        var signature = "v0=".concat(hashForVerify);
+        var valid = request.headers['x-zm-signature'] === signature;
+        var result = {
+            valid: valid,
             event: JSON.parse(requestBodyString)
         };
         return result;
     };
 }
 
-const ZOOM_WEBHOOK_URL_VALIDATION_EVENT_TYPE = 'endpoint.url_validation';
+var 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;
+ */ function zoomWebhookEventValidationFunction(zoomSecretToken) {
+    return function(event) {
+        var plainToken = event.payload.plainToken;
         if (!plainToken) {
-            throw new Error(`The expected plaintoken value was not provided by the event's payload.`);
+            throw new Error("The expected plaintoken value was not provided by the event's payload.");
         }
-        const encryptedToken = createHmac('sha256', zoomSecretToken).update(plainToken).digest('hex');
-        const result = {
-            plainToken,
-            encryptedToken
+        var encryptedToken = createHmac('sha256', zoomSecretToken).update(plainToken).digest('hex');
+        var result = {
+            plainToken: plainToken,
+            encryptedToken: encryptedToken
         };
         return result;
     };
 }
 
-/**
- * Service that makes system changes based on Zoom webhook events.
- */
-let ZoomWebhookService = class ZoomWebhookService {
-    logger = new Logger('ZoomWebhookService');
-    _verifier;
-    _validator;
-    handler = zoomEventHandlerFactory();
-    configure = zoomEventHandlerConfigurerFactory(this.handler);
-    constructor(config) {
-        this._verifier = zoomWebhookEventVerifier(config.webhookConfig.zoomSecretToken);
-        this._validator = zoomWebhookEventValidationFunction(config.webhookConfig.zoomSecretToken);
+function asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
     }
-    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);
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$1(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _class_call_check$4(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties$3(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class$3(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$3(Constructor.prototype, protoProps);
+    return Constructor;
+}
+function _define_property$3(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _ts_generator$1(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
         }
-        const result = {
-            valid,
-            handled,
-            event,
-            validationEventResponse
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
         };
-        return result;
     }
-    async updateForZoomEvent(event) {
-        const handled = await this.handler(event);
-        if (!handled) {
-            this.logger.warn('Received unexpected/unhandled zoom event: ', event);
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
         }
-        return handled;
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
     }
-};
+}
+/**
+ * Service that makes system changes based on Zoom webhook events.
+ */ var ZoomWebhookService = /*#__PURE__*/ function() {
+    function ZoomWebhookService(config) {
+        _class_call_check$4(this, ZoomWebhookService);
+        _define_property$3(this, "logger", new Logger('ZoomWebhookService'));
+        _define_property$3(this, "_verifier", void 0);
+        _define_property$3(this, "_validator", void 0);
+        _define_property$3(this, "handler", zoomEventHandlerFactory());
+        _define_property$3(this, "configure", zoomEventHandlerConfigurerFactory(this.handler));
+        this._verifier = zoomWebhookEventVerifier(config.webhookConfig.zoomSecretToken);
+        this._validator = zoomWebhookEventValidationFunction(config.webhookConfig.zoomSecretToken);
+    }
+    _create_class$3(ZoomWebhookService, [
+        {
+            key: "updateForWebhook",
+            value: function updateForWebhook(req, rawBody) {
+                return _async_to_generator$1(function() {
+                    var _this__verifier, valid, event, handled, validationEventResponse, result;
+                    return _ts_generator$1(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                _this__verifier = this._verifier(req, rawBody), valid = _this__verifier.valid, event = _this__verifier.event;
+                                handled = false;
+                                if (!!valid) return [
+                                    3,
+                                    1
+                                ];
+                                this.logger.warn('Received invalid zoom event: ', event);
+                                return [
+                                    3,
+                                    4
+                                ];
+                            case 1:
+                                if (!(event.event === ZOOM_WEBHOOK_URL_VALIDATION_EVENT_TYPE)) return [
+                                    3,
+                                    2
+                                ];
+                                validationEventResponse = this._validator(event);
+                                handled = true;
+                                return [
+                                    3,
+                                    4
+                                ];
+                            case 2:
+                                return [
+                                    4,
+                                    this.updateForZoomEvent(event)
+                                ];
+                            case 3:
+                                handled = _state.sent();
+                                _state.label = 4;
+                            case 4:
+                                result = {
+                                    valid: valid,
+                                    handled: handled,
+                                    event: event,
+                                    validationEventResponse: validationEventResponse
+                                };
+                                return [
+                                    2,
+                                    result
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "updateForZoomEvent",
+            value: function updateForZoomEvent(event) {
+                return _async_to_generator$1(function() {
+                    var handled;
+                    return _ts_generator$1(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    this.handler(event)
+                                ];
+                            case 1:
+                                handled = _state.sent();
+                                if (!handled) {
+                                    this.logger.warn('Received unexpected/unhandled zoom event: ', event);
+                                }
+                                return [
+                                    2,
+                                    handled
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        }
+    ]);
+    return ZoomWebhookService;
+}();
 ZoomWebhookService = __decorate([
     Injectable(),
     __param(0, Inject(ZoomWebhookServiceConfig))
 ], ZoomWebhookService);
 
-let ZoomWebhookController = class ZoomWebhookController {
-    zoomWebhookService;
-    constructor(zoomWebhookService) {
-        this.zoomWebhookService = zoomWebhookService;
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
     }
-    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);
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _class_call_check$3(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties$2(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class$2(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$2(Constructor.prototype, protoProps);
+    return Constructor;
+}
+function _define_property$2(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
         }
-        else {
-            response.json({});
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
         }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
     }
-};
+}
+var ZoomWebhookController = /*#__PURE__*/ function() {
+    function ZoomWebhookController(zoomWebhookService) {
+        _class_call_check$3(this, ZoomWebhookController);
+        _define_property$2(this, "zoomWebhookService", void 0);
+        this.zoomWebhookService = zoomWebhookService;
+    }
+    _create_class$2(ZoomWebhookController, [
+        {
+            key: "handleZoomWebhook",
+            value: function handleZoomWebhook(res, req, rawBody) {
+                return _async_to_generator(function() {
+                    var _ref, valid, validationEventResponse, response;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    this.zoomWebhookService.updateForWebhook(req, rawBody)
+                                ];
+                            case 1:
+                                _ref = _state.sent(), valid = _ref.valid, validationEventResponse = _ref.validationEventResponse;
+                                response = res.status(200); // always return a 200 status code
+                                if (valid && validationEventResponse) {
+                                    response.json(validationEventResponse);
+                                } else {
+                                    response.json({});
+                                }
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        }
+    ]);
+    return ZoomWebhookController;
+}();
 __decorate([
     Post(),
     __param(0, Res()),
@@ -541,8 +1481,13 @@ ZoomWebhookController = __decorate([
     __param(0, Inject(ZoomWebhookService))
 ], ZoomWebhookController);
 
+function _class_call_check$2(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
 function zoomWebhookServiceConfigFactory(configService) {
-    const config = {
+    var config = {
         webhookConfig: {
             zoomSecretToken: configService.get(ZOOM_SECRET_TOKEN_ENV_VAR)
         }
@@ -552,18 +1497,26 @@ function zoomWebhookServiceConfigFactory(configService) {
 }
 /**
  * Configures webhooks for the service.
- */
-let ZoomWebhookModule = class ZoomWebhookModule {
+ */ var ZoomWebhookModule = function ZoomWebhookModule() {
+    _class_call_check$2(this, ZoomWebhookModule);
 };
 ZoomWebhookModule = __decorate([
     Module({
-        imports: [ConfigModule],
-        controllers: [ZoomWebhookController],
-        exports: [ZoomWebhookService],
+        imports: [
+            ConfigModule
+        ],
+        controllers: [
+            ZoomWebhookController
+        ],
+        exports: [
+            ZoomWebhookService
+        ],
         providers: [
             {
                 provide: ZoomWebhookServiceConfig,
-                inject: [ConfigService],
+                inject: [
+                    ConfigService
+                ],
                 useFactory: zoomWebhookServiceConfigFactory
             },
             ZoomWebhookService
@@ -571,86 +1524,257 @@ ZoomWebhookModule = __decorate([
     })
 ], ZoomWebhookModule);
 
-/**
- * Configuration for ZoomService
- */
-class ZoomServiceConfig {
-    zoom;
-    factoryConfig;
-    static assertValidConfig(config) {
-        // TODO?
+function _class_call_check$1(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
     }
 }
-
-let ZoomApi = class ZoomApi {
-    config;
-    zoomOAuthApi;
-    zoom;
-    get zoomContext() {
-        return this.zoom.zoomServerContext;
-    }
-    get zoomRateLimiter() {
-        return this.zoom.zoomServerContext.zoomRateLimiter;
+function _defineProperties$1(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
     }
-    constructor(config, zoomOAuthApi) {
-        this.config = config;
-        this.zoomOAuthApi = zoomOAuthApi;
-        this.zoom = zoomFactory({
-            ...config.factoryConfig,
-            oauthContext: zoomOAuthApi.oauthContext
-        })(config.zoom);
-    }
-    // MARK: Users
-    get getUser() {
-        return getUser(this.zoomContext);
-    }
-    get listUsers() {
-        return listUsers(this.zoomContext);
-    }
-    get listUsersPageFactory() {
-        return listUsersPageFactory(this.zoomContext);
+}
+function _create_class$1(Constructor, protoProps, staticProps) {
+    if (staticProps) _defineProperties$1(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property$1(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
     }
-    // MARK: Meetings
-    get listMeetingsForUser() {
-        return listMeetingsForUser(this.zoomContext);
+    return obj;
+}
+/**
+ * Configuration for ZoomService
+ */ var ZoomServiceConfig = /*#__PURE__*/ function() {
+    function ZoomServiceConfig() {
+        _class_call_check$1(this, ZoomServiceConfig);
+        _define_property$1(this, "zoom", void 0);
+        _define_property$1(this, "factoryConfig", void 0);
     }
-    get listMeetingsForUserPageFactory() {
-        return listMeetingsForUserPageFactory(this.zoomContext);
+    _create_class$1(ZoomServiceConfig, null, [
+        {
+            key: "assertValidConfig",
+            value: function assertValidConfig(config) {
+            // TODO?
+            }
+        }
+    ]);
+    return ZoomServiceConfig;
+} 
+();
+
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
     }
-    get createMeetingForUser() {
-        return createMeetingForUser(this.zoomContext);
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
     }
-    get getMeeting() {
-        return getMeeting(this.zoomContext);
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
     }
-    get updateMeeting() {
-        return updateMeeting(this.zoomContext);
+    return obj;
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
     }
-    get deleteMeeting() {
-        return deleteMeeting(this.zoomContext);
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        keys.push.apply(keys, symbols);
     }
-    // MARK: Past Meetings
-    get getPastMeeting() {
-        return getPastMeeting(this.zoomContext);
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
     }
-    get getPastMeetingParticipants() {
-        return getPastMeetingParticipants(this.zoomContext);
+    return target;
+}
+var ZoomApi = /*#__PURE__*/ function() {
+    function ZoomApi(config, zoomOAuthApi) {
+        _class_call_check(this, ZoomApi);
+        _define_property(this, "config", void 0);
+        _define_property(this, "zoomOAuthApi", void 0);
+        _define_property(this, "zoom", void 0);
+        this.config = config;
+        this.zoomOAuthApi = zoomOAuthApi;
+        this.zoom = zoomFactory(_object_spread_props(_object_spread({}, config.factoryConfig), {
+            oauthContext: zoomOAuthApi.oauthContext
+        }))(config.zoom);
     }
-};
+    _create_class(ZoomApi, [
+        {
+            key: "zoomContext",
+            get: function get() {
+                return this.zoom.zoomServerContext;
+            }
+        },
+        {
+            key: "zoomRateLimiter",
+            get: function get() {
+                return this.zoom.zoomServerContext.zoomRateLimiter;
+            }
+        },
+        {
+            key: "getUser",
+            get: // MARK: Users
+            function get() {
+                return getUser(this.zoomContext);
+            }
+        },
+        {
+            key: "listUsers",
+            get: function get() {
+                return listUsers(this.zoomContext);
+            }
+        },
+        {
+            key: "listUsersPageFactory",
+            get: function get() {
+                return listUsersPageFactory(this.zoomContext);
+            }
+        },
+        {
+            key: "listMeetingsForUser",
+            get: // MARK: Meetings
+            function get() {
+                return listMeetingsForUser(this.zoomContext);
+            }
+        },
+        {
+            key: "listMeetingsForUserPageFactory",
+            get: function get() {
+                return listMeetingsForUserPageFactory(this.zoomContext);
+            }
+        },
+        {
+            key: "createMeetingForUser",
+            get: function get() {
+                return createMeetingForUser(this.zoomContext);
+            }
+        },
+        {
+            key: "getMeeting",
+            get: function get() {
+                return getMeeting(this.zoomContext);
+            }
+        },
+        {
+            key: "updateMeeting",
+            get: function get() {
+                return updateMeeting(this.zoomContext);
+            }
+        },
+        {
+            key: "deleteMeeting",
+            get: function get() {
+                return deleteMeeting(this.zoomContext);
+            }
+        },
+        {
+            key: "getPastMeeting",
+            get: // MARK: Past Meetings
+            function get() {
+                return getPastMeeting(this.zoomContext);
+            }
+        },
+        {
+            key: "getPastMeetingParticipants",
+            get: function get() {
+                return getPastMeetingParticipants(this.zoomContext);
+            }
+        }
+    ]);
+    return ZoomApi;
+}();
 ZoomApi = __decorate([
     Injectable(),
     __param(0, Inject(ZoomServiceConfig)),
     __param(1, Inject(ZoomOAuthApi))
 ], ZoomApi);
-class ZoomApiUserContext {
-    constructor(refreshToken) {
-        // TODO: ...
-    }
-}
+var ZoomApiUserContext = function ZoomApiUserContext(refreshToken) {
+    _class_call_check(this, ZoomApiUserContext);
+} 
+;
 
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
 // MARK: Provider Factories
 function zoomServiceConfigFactory(configService) {
-    const config = {
+    var config = {
         zoom: {}
     };
     ZoomServiceConfig.assertValidConfig(config);
@@ -662,22 +1786,28 @@ function zoomServiceConfigFactory(configService) {
  * @param provide
  * @param useFactory
  * @returns
- */
-function appZoomModuleMetadata(config) {
-    const { dependencyModule, imports, exports: exports$1, providers } = config;
-    const dependencyModuleImport = dependencyModule ? [dependencyModule] : [];
+ */ function appZoomModuleMetadata(config) {
+    var dependencyModule = config.dependencyModule, imports = config.imports, exports$1 = config.exports, providers = config.providers;
+    var dependencyModuleImport = dependencyModule ? [
+        dependencyModule
+    ] : [];
     return {
-        imports: [ConfigModule, ...dependencyModuleImport, ...(imports ?? [])],
-        exports: [ZoomApi, ...(exports$1 ?? [])],
+        imports: [
+            ConfigModule
+        ].concat(_to_consumable_array(dependencyModuleImport), _to_consumable_array(imports !== null && imports !== void 0 ? imports : [])),
+        exports: [
+            ZoomApi
+        ].concat(_to_consumable_array(exports$1 !== null && exports$1 !== void 0 ? exports$1 : [])),
         providers: [
             {
                 provide: ZoomServiceConfig,
-                inject: [ConfigService],
+                inject: [
+                    ConfigService
+                ],
                 useFactory: zoomServiceConfigFactory
             },
-            ZoomApi,
-            ...(providers ?? [])
-        ]
+            ZoomApi
+        ].concat(_to_consumable_array(providers !== null && providers !== void 0 ? providers : []))
     };
 }