@dereekb/zoom 13.2.2 → 13.3.0

package/index.esm.js

@@ -1,7 +1,54 @@
-import { fetchPageFactory, FetchResponseError, mergeMakeUrlSearchParamsOptions, makeUrlSearchParams, FetchRequestFactoryError, rateLimitedFetchHandler, fetchApiFetchService, fetchJsonFunction, returnNullHandleFetchJsonParseErrorFunction } from '@dereekb/util/fetch';
+import { fetchPageFactory, mergeMakeUrlSearchParamsOptions, FetchResponseError, makeUrlSearchParams, FetchRequestFactoryError, rateLimitedFetchHandler, fetchJsonFunction, returnNullHandleFetchJsonParseErrorFunction, fetchApiFetchService } from '@dereekb/util/fetch';
 import { MS_IN_SECOND, asArray, resetPeriodPromiseRateLimiter, MS_IN_MINUTE } from '@dereekb/util';
 import { BaseError } from 'make-error';
 
+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 _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$2(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(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(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));
+        });
+    }
+    return target;
+}
 /**
  * The Zoom API returns the data for a page for a specific key.
  *
@@ -9,17 +56,16 @@ import { BaseError } from 'make-error';
  
  * @param dataTypeKey
  * @returns
- */
-function mapToZoomPageResult(dataTypeKey) {
-    return (data) => {
-        const { next_page_token, page_count, page_number, page_size, total_records } = data;
+ */ function mapToZoomPageResult(dataTypeKey) {
+    return function(data) {
+        var next_page_token = data.next_page_token, page_count = data.page_count, page_number = data.page_number, page_size = data.page_size, total_records = data.total_records;
         return {
             data: data[dataTypeKey],
-            next_page_token,
-            page_count,
-            page_number,
-            page_size,
-            total_records
+            next_page_token: next_page_token,
+            page_count: page_count,
+            page_number: page_number,
+            page_size: page_size,
+            total_records: total_records
         };
     };
 }
@@ -29,68 +75,307 @@ function mapToZoomPageResult(dataTypeKey) {
  * @param fetch
  * @param defaults
  * @returns
- */
-function zoomFetchPageFactory(fetch, defaults) {
-    return fetchPageFactory({
-        ...defaults,
-        fetch,
-        readFetchPageResultInfo: function (result) {
+ */ function zoomFetchPageFactory(fetch, defaults) {
+    return fetchPageFactory(_object_spread_props(_object_spread({}, defaults), {
+        fetch: fetch,
+        readFetchPageResultInfo: function readFetchPageResultInfo(result) {
             return {
                 nextPageCursor: result.next_page_token,
                 hasNext: Boolean(result.next_page_token) // has more when a non-empty next_page_token is returned
             };
         },
-        buildInputForNextPage: function (pageResult, input, options) {
-            return { ...input, next_page_token: pageResult.nextPageCursor, page_size: options.maxItemsPerPage ?? input.page_size };
+        buildInputForNextPage: function buildInputForNextPage(pageResult, input, options) {
+            var _options_maxItemsPerPage;
+            return _object_spread_props(_object_spread({}, input), {
+                next_page_token: pageResult.nextPageCursor,
+                page_size: (_options_maxItemsPerPage = options.maxItemsPerPage) !== null && _options_maxItemsPerPage !== void 0 ? _options_maxItemsPerPage : input.page_size
+            });
         }
-    });
+    }));
 }
 
+function _assert_this_initialized$1(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function asyncGeneratorStep$5(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$5(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$5(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$5(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _call_super$1(_this, derived, args) {
+    derived = _get_prototype_of$1(derived);
+    return _possible_constructor_return$1(_this, _is_native_reflect_construct$1() ? Reflect.construct(derived, args || [], _get_prototype_of$1(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check$1(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+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);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    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;
+    }
+    return obj;
+}
+function _get_prototype_of$1(o) {
+    _get_prototype_of$1 = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of$1(o);
+}
+function _inherits$1(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of$1(subClass, superClass);
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _possible_constructor_return$1(self, call) {
+    if (call && (_type_of$1(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized$1(self);
+}
+function _set_prototype_of$1(o, p) {
+    _set_prototype_of$1 = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of$1(o, p);
+}
+function _type_of$1(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct$1() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct$1 = function() {
+        return !!result;
+    })();
+}
+function _ts_generator$5(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
+        };
+    }
+}
 /**
  * A code used in some cases to denote success.
- */
-const ZOOM_SUCCESS_CODE = 'SUCCESS';
+ */ var ZOOM_SUCCESS_CODE = 'SUCCESS';
 /**
  * Zoom Server Error
- */
-class ZoomServerError extends BaseError {
-    error;
-    get code() {
-        return this.error.code;
-    }
-    constructor(error) {
-        super(error.message);
-        this.error = error;
+ */ var ZoomServerError = /*#__PURE__*/ function(BaseError) {
+    _inherits$1(ZoomServerError, BaseError);
+    function ZoomServerError(error) {
+        _class_call_check$1(this, ZoomServerError);
+        var _this;
+        _this = _call_super$1(this, ZoomServerError, [
+            error.message
+        ]), _define_property$1(_this, "error", void 0);
+        _this.error = error;
+        return _this;
     }
-}
+    _create_class(ZoomServerError, [
+        {
+            key: "code",
+            get: function get() {
+                return this.error.code;
+            }
+        }
+    ]);
+    return ZoomServerError;
+}(BaseError);
 /**
  * Zoom Server Error that includes the FetchResponseError
- */
-class ZoomServerFetchResponseError extends ZoomServerError {
-    data;
-    responseError;
-    constructor(data, responseError) {
-        super(data);
-        this.data = data;
-        this.responseError = responseError;
+ */ var ZoomServerFetchResponseError = /*#__PURE__*/ function(ZoomServerError) {
+    _inherits$1(ZoomServerFetchResponseError, ZoomServerError);
+    function ZoomServerFetchResponseError(data, responseError) {
+        _class_call_check$1(this, ZoomServerFetchResponseError);
+        var _this;
+        _this = _call_super$1(this, ZoomServerFetchResponseError, [
+            data
+        ]), _define_property$1(_this, "data", void 0), _define_property$1(_this, "responseError", void 0);
+        _this.data = data;
+        _this.responseError = responseError;
+        return _this;
     }
-}
+    return ZoomServerFetchResponseError;
+}(ZoomServerError);
 /**
  * Creates a logZoomServerErrorFunction that logs the error to console.
  *
  * @param zoomApiNamePrefix Prefix to use when logging. I.E. ZoomError, etc.
  * @returns
- */
-function logZoomServerErrorFunction(zoomApiNamePrefix) {
-    return (error) => {
-        if (error instanceof ZoomServerFetchResponseError) {
-            console.log(`${zoomApiNamePrefix}Error(${error.responseError.response.status}): `, { error, errorData: error.data });
-        }
-        else if (error instanceof ZoomServerError) {
-            console.log(`${zoomApiNamePrefix}Error(code:${error.code}): `, { error });
-        }
-        else {
-            console.log(`${zoomApiNamePrefix}Error(name:${error.name}): `, { error });
+ */ function logZoomServerErrorFunction(zoomApiNamePrefix) {
+    return function(error) {
+        if (_instanceof(error, ZoomServerFetchResponseError)) {
+            console.log("".concat(zoomApiNamePrefix, "Error(").concat(error.responseError.response.status, "): "), {
+                error: error,
+                errorData: error.data
+            });
+        } else if (_instanceof(error, ZoomServerError)) {
+            console.log("".concat(zoomApiNamePrefix, "Error(code:").concat(error.code, "): "), {
+                error: error
+            });
+        } else {
+            console.log("".concat(zoomApiNamePrefix, "Error(name:").concat(error.name, "): "), {
+                error: error
+            });
         }
     };
 }
@@ -99,84 +384,131 @@ function logZoomServerErrorFunction(zoomApiNamePrefix) {
  *
  * @param fetch
  * @returns
- */
-function handleZoomErrorFetchFactory(parseZoomError, defaultLogError) {
-    return (fetch, logError = defaultLogError) => {
-        return async (x, y) => {
-            try {
-                return await fetch(x, y); // await to catch thrown errors
-            }
-            catch (e) {
-                if (e instanceof FetchResponseError) {
-                    const error = await parseZoomError(e);
-                    if (error) {
-                        logError(error); // log before throwing.
-                        throw error;
+ */ function handleZoomErrorFetchFactory(parseZoomError, defaultLogError) {
+    return function(fetch) {
+        var logError = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : defaultLogError;
+        return function(x, y) {
+            return _async_to_generator$5(function() {
+                var e, error;
+                return _ts_generator$5(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            _state.trys.push([
+                                0,
+                                2,
+                                ,
+                                5
+                            ]);
+                            return [
+                                4,
+                                fetch(x, y)
+                            ];
+                        case 1:
+                            return [
+                                2,
+                                _state.sent()
+                            ]; // await to catch thrown errors
+                        case 2:
+                            e = _state.sent();
+                            if (!_instanceof(e, FetchResponseError)) return [
+                                3,
+                                4
+                            ];
+                            return [
+                                4,
+                                parseZoomError(e)
+                            ];
+                        case 3:
+                            error = _state.sent();
+                            if (error) {
+                                logError(error); // log before throwing.
+                                throw error;
+                            }
+                            _state.label = 4;
+                        case 4:
+                            throw e;
+                        case 5:
+                            return [
+                                2
+                            ];
                     }
-                }
-                throw e;
-            }
+                });
+            })();
         };
     };
 }
 // MARK: Parsed Errors
 /**
  * The status code that Zoom uses to indicates that too many requests have been made in a short period of time.
- */
-const ZOOM_TOO_MANY_REQUESTS_HTTP_STATUS_CODE = 429;
+ */ var ZOOM_TOO_MANY_REQUESTS_HTTP_STATUS_CODE = 429;
 /**
  * Also shares the same 429 code as ZOOM_TOO_MANY_REQUESTS_HTTP_STATUS_CODE.
- */
-const ZOOM_TOO_MANY_REQUESTS_ERROR_CODE = 429;
-const ZOOM_RATE_LIMIT_CATEGORY_HEADER = 'X-RateLimit-Category';
-const ZOOM_RATE_LIMIT_TYPE_HEADER = 'X-RateLimit-Type';
-const ZOOM_RATE_LIMIT_LIMIT_HEADER = 'X-RateLimit-Limit';
-const ZOOM_RATE_LIMIT_REMAINING_HEADER = 'X-RateLimit-Remaining';
-const ZOOM_RATE_LIMIT_RETRY_AFTER_HEADER = 'Retry-After';
-const DEFAULT_ZOOM_API_RATE_LIMIT = 2;
-const DEFAULT_ZOOM_API_RATE_LIMIT_RESET_PERIOD = MS_IN_SECOND;
+ */ var ZOOM_TOO_MANY_REQUESTS_ERROR_CODE = 429;
+var ZOOM_RATE_LIMIT_CATEGORY_HEADER = 'X-RateLimit-Category';
+var ZOOM_RATE_LIMIT_TYPE_HEADER = 'X-RateLimit-Type';
+var ZOOM_RATE_LIMIT_LIMIT_HEADER = 'X-RateLimit-Limit';
+var ZOOM_RATE_LIMIT_REMAINING_HEADER = 'X-RateLimit-Remaining';
+var ZOOM_RATE_LIMIT_RETRY_AFTER_HEADER = 'Retry-After';
+var DEFAULT_ZOOM_API_RATE_LIMIT = 2;
+var DEFAULT_ZOOM_API_RATE_LIMIT_RESET_PERIOD = MS_IN_SECOND;
 function zoomRateLimitHeaderDetails(headers) {
-    const limitHeader = headers.get(ZOOM_RATE_LIMIT_LIMIT_HEADER);
-    const remainingHeader = headers.get(ZOOM_RATE_LIMIT_REMAINING_HEADER);
-    const retryAfterHeader = headers.get(ZOOM_RATE_LIMIT_RETRY_AFTER_HEADER);
-    const categoryHeader = headers.get(ZOOM_RATE_LIMIT_CATEGORY_HEADER);
-    const typeHeader = headers.get(ZOOM_RATE_LIMIT_TYPE_HEADER);
-    let result = null;
+    var limitHeader = headers.get(ZOOM_RATE_LIMIT_LIMIT_HEADER);
+    var remainingHeader = headers.get(ZOOM_RATE_LIMIT_REMAINING_HEADER);
+    var retryAfterHeader = headers.get(ZOOM_RATE_LIMIT_RETRY_AFTER_HEADER);
+    var categoryHeader = headers.get(ZOOM_RATE_LIMIT_CATEGORY_HEADER);
+    var typeHeader = headers.get(ZOOM_RATE_LIMIT_TYPE_HEADER);
+    var result = null;
     if (categoryHeader != null && typeHeader != null) {
-        const category = categoryHeader;
-        const type = typeHeader;
-        const limit = limitHeader ? Number(limitHeader) : undefined;
-        const remaining = remainingHeader ? Number(remainingHeader) : undefined;
-        const retryAfter = retryAfterHeader ? Number(retryAfterHeader) : undefined;
-        const retryAfterAt = retryAfterHeader ? new Date(retryAfterHeader) : undefined;
-        result = { limit, remaining, retryAfter, retryAfterAt, category, type };
+        var category = categoryHeader;
+        var type = typeHeader;
+        var limit = limitHeader ? Number(limitHeader) : undefined;
+        var remaining = remainingHeader ? Number(remainingHeader) : undefined;
+        var retryAfter = retryAfterHeader ? Number(retryAfterHeader) : undefined;
+        var retryAfterAt = retryAfterHeader ? new Date(retryAfterHeader) : undefined;
+        result = {
+            limit: limit,
+            remaining: remaining,
+            retryAfter: retryAfter,
+            retryAfterAt: retryAfterAt,
+            category: category,
+            type: type
+        };
     }
     return result;
 }
-class ZoomTooManyRequestsError extends ZoomServerFetchResponseError {
-    get headerDetails() {
-        return zoomRateLimitHeaderDetails(this.responseError.response.headers);
+var ZoomTooManyRequestsError = /*#__PURE__*/ function(ZoomServerFetchResponseError) {
+    _inherits$1(ZoomTooManyRequestsError, ZoomServerFetchResponseError);
+    function ZoomTooManyRequestsError() {
+        _class_call_check$1(this, ZoomTooManyRequestsError);
+        return _call_super$1(this, ZoomTooManyRequestsError, arguments);
     }
-}
+    _create_class(ZoomTooManyRequestsError, [
+        {
+            key: "headerDetails",
+            get: function get() {
+                return zoomRateLimitHeaderDetails(this.responseError.response.headers);
+            }
+        }
+    ]);
+    return ZoomTooManyRequestsError;
+}(ZoomServerFetchResponseError);
 /**
  * Function that parses/transforms a ZoomServerErrorData into a general ZoomServerError or other known error type.
  *
  * @param errorResponseData
  * @param responseError
  * @returns
- */
-function parseZoomServerErrorData(zoomServerError, responseError) {
-    let result;
+ */ function parseZoomServerErrorData(zoomServerError, responseError) {
+    var result;
     if (responseError.response.status === ZOOM_TOO_MANY_REQUESTS_HTTP_STATUS_CODE) {
         result = new ZoomTooManyRequestsError(zoomServerError, responseError);
         console.warn('ZoomTooManyRequestsError', {
-            result,
-            responseError,
+            result: result,
+            responseError: responseError,
             headerDetails: result.headerDetails
         });
-    }
-    else if (zoomServerError) {
-        switch (zoomServerError.code) {
+    } else if (zoomServerError) {
+        switch(zoomServerError.code){
             default:
                 result = new ZoomServerFetchResponseError(zoomServerError, responseError);
                 break;
@@ -188,18 +520,24 @@ function parseZoomServerErrorData(zoomServerError, responseError) {
  * Returns a pre-configured MakeUrlSearchParamsOptions that omits the silenceError key.
  *
  * If other options are input, it merges those two options together and adds silenceError to the omitted keys.
- */
-function omitSilenceZoomErrorKeys(options) {
-    const omitKeys = ['silenceError'];
-    return mergeMakeUrlSearchParamsOptions([options, { omitKeys }]);
+ */ function omitSilenceZoomErrorKeys(options) {
+    var omitKeys = [
+        'silenceError'
+    ];
+    return mergeMakeUrlSearchParamsOptions([
+        options,
+        {
+            omitKeys: omitKeys
+        }
+    ]);
 }
 function silenceZoomErrorWithCodesFunction(codes, returnFn) {
-    const codesSet = new Set(asArray(codes));
-    return (silence) => {
-        return (reason) => {
-            if (silence !== false && reason instanceof ZoomServerFetchResponseError) {
+    var codesSet = new Set(asArray(codes));
+    return function(silence) {
+        return function(reason) {
+            if (silence !== false && _instanceof(reason, ZoomServerFetchResponseError)) {
                 if (codesSet.has(reason.code)) {
-                    return returnFn?.(reason);
+                    return returnFn === null || returnFn === void 0 ? void 0 : returnFn(reason);
                 }
             }
             throw reason;
@@ -209,25 +547,26 @@ function silenceZoomErrorWithCodesFunction(codes, returnFn) {
 
 /**
  * https://developers.zoom.us/docs/api/rest/reference/zoom-api/methods/#operation/meeting
- */
-function getMeeting(context) {
-    return (input) => context.fetchJson(`/meetings/${input.meetingId}`, 'GET');
+ */ function getMeeting(context) {
+    return function(input) {
+        return context.fetchJson("/meetings/".concat(input.meetingId), 'GET');
+    };
 }
 /**
  * https://developers.zoom.us/docs/api/rest/reference/zoom-api/methods/#operation/meetings
- */
-function listMeetingsForUser(context) {
-    return (input) => context.fetchJson(`/users/${input.user}/meetings`, 'GET').then(mapToZoomPageResult('meetings'));
+ */ function listMeetingsForUser(context) {
+    return function(input) {
+        return context.fetchJson("/users/".concat(input.user, "/meetings"), 'GET').then(mapToZoomPageResult('meetings'));
+    };
 }
 function listMeetingsForUserPageFactory(context) {
     return zoomFetchPageFactory(listMeetingsForUser(context));
 }
 /**
  * https://developers.zoom.us/docs/api/meetings/#tag/meetings/POST/users/{userId}/meetings
- */
-function createMeetingForUser(context) {
-    return (input) => {
-        return context.fetchJson(`/users/${input.user}/meetings`, {
+ */ function createMeetingForUser(context) {
+    return function(input) {
+        return context.fetchJson("/users/".concat(input.user, "/meetings"), {
             method: 'POST',
             body: JSON.stringify(input.template)
         });
@@ -235,32 +574,38 @@ function createMeetingForUser(context) {
 }
 /**
  * https://developers.zoom.us/docs/api/meetings/#tag/meetings/PUT/meetings/{meetingId}
- */
-function updateMeeting(context) {
-    return (input) => context.fetchJson(`/meetings/${input.meetingId}?${makeUrlSearchParams({ occurrence_id: input.occurrence_id })}`, {
-        method: 'PATCH',
-        body: JSON.stringify(input.template)
-    });
+ */ function updateMeeting(context) {
+    return function(input) {
+        return context.fetchJson("/meetings/".concat(input.meetingId, "?").concat(makeUrlSearchParams({
+            occurrence_id: input.occurrence_id
+        })), {
+            method: 'PATCH',
+            body: JSON.stringify(input.template)
+        });
+    };
 }
-const DELETE_MEETING_DOES_NOT_EXIST_ERROR_CODE = 3001;
+var DELETE_MEETING_DOES_NOT_EXIST_ERROR_CODE = 3001;
 /**
  * https://developers.zoom.us/docs/api/meetings/#tag/meetings/DELETE/meetings/{meetingId}
- */
-function deleteMeeting(context) {
-    const silenceDoesNotExistError = silenceZoomErrorWithCodesFunction(DELETE_MEETING_DOES_NOT_EXIST_ERROR_CODE);
-    return (input) => context.fetchJson(`/meetings/${input.meetingId}?${makeUrlSearchParams(input, omitSilenceZoomErrorKeys())}`, 'DELETE').catch(silenceDoesNotExistError(input.silenceError));
+ */ function deleteMeeting(context) {
+    var silenceDoesNotExistError = silenceZoomErrorWithCodesFunction(DELETE_MEETING_DOES_NOT_EXIST_ERROR_CODE);
+    return function(input) {
+        return context.fetchJson("/meetings/".concat(input.meetingId, "?").concat(makeUrlSearchParams(input, omitSilenceZoomErrorKeys())), 'DELETE').catch(silenceDoesNotExistError(input.silenceError));
+    };
 }
 /**
  * https://developers.zoom.us/docs/api/meetings/#tag/meetings/GET/past_meetings/{meetingId}
- */
-function getPastMeeting(context) {
-    return (input) => context.fetchJson(`/past_meetings/${input.meetingId}`, 'GET');
+ */ function getPastMeeting(context) {
+    return function(input) {
+        return context.fetchJson("/past_meetings/".concat(input.meetingId), 'GET');
+    };
 }
 /**
  * https://developers.zoom.us/docs/api/meetings/#tag/meetings/GET/past_meetings/{meetingId}/participants
- */
-function getPastMeetingParticipants(context) {
-    return (input) => context.fetchJson(`/past_meetings/${input.meetingId}/participants`, 'GET').then(mapToZoomPageResult('participants'));
+ */ function getPastMeetingParticipants(context) {
+    return function(input) {
+        return context.fetchJson("/past_meetings/".concat(input.meetingId, "/participants"), 'GET').then(mapToZoomPageResult('participants'));
+    };
 }
 function getPastMeetingParticipantsPageFactory(context) {
     return zoomFetchPageFactory(getPastMeetingParticipants(context));
@@ -274,9 +619,8 @@ function getPastMeetingParticipantsPageFactory(context) {
  * - `4` - A PMI Meeting.
  * - `8` - A recurring meeting with fixed time.
  * - `10` - A screen share only meeting.
- */
-var ZoomMeetingType;
-(function (ZoomMeetingType) {
+ */ var ZoomMeetingType;
+(function(ZoomMeetingType) {
     ZoomMeetingType[ZoomMeetingType["INSTANT"] = 1] = "INSTANT";
     ZoomMeetingType[ZoomMeetingType["SCHEDULED"] = 2] = "SCHEDULED";
     ZoomMeetingType[ZoomMeetingType["RECURRING_NO_FIXED_TIME"] = 3] = "RECURRING_NO_FIXED_TIME";
@@ -285,13 +629,13 @@ var ZoomMeetingType;
     ZoomMeetingType[ZoomMeetingType["SCREEN_SHARE_ONLY"] = 10] = "SCREEN_SHARE_ONLY";
 })(ZoomMeetingType || (ZoomMeetingType = {}));
 var ZoomRecurrenceType;
-(function (ZoomRecurrenceType) {
+(function(ZoomRecurrenceType) {
     ZoomRecurrenceType[ZoomRecurrenceType["DAILY"] = 1] = "DAILY";
     ZoomRecurrenceType[ZoomRecurrenceType["WEEKLY"] = 2] = "WEEKLY";
     ZoomRecurrenceType[ZoomRecurrenceType["MONTHLY"] = 3] = "MONTHLY";
 })(ZoomRecurrenceType || (ZoomRecurrenceType = {}));
 var ZoomMonthlyWeek;
-(function (ZoomMonthlyWeek) {
+(function(ZoomMonthlyWeek) {
     ZoomMonthlyWeek[ZoomMonthlyWeek["LAST_WEEK"] = -1] = "LAST_WEEK";
     ZoomMonthlyWeek[ZoomMonthlyWeek["FIRST_WEEK"] = 1] = "FIRST_WEEK";
     ZoomMonthlyWeek[ZoomMonthlyWeek["SECOND_WEEK"] = 2] = "SECOND_WEEK";
@@ -299,7 +643,7 @@ var ZoomMonthlyWeek;
     ZoomMonthlyWeek[ZoomMonthlyWeek["FOURTH_WEEK"] = 4] = "FOURTH_WEEK";
 })(ZoomMonthlyWeek || (ZoomMonthlyWeek = {}));
 var ZoomMonthlyWeekDay;
-(function (ZoomMonthlyWeekDay) {
+(function(ZoomMonthlyWeekDay) {
     ZoomMonthlyWeekDay[ZoomMonthlyWeekDay["SUNDAY"] = 1] = "SUNDAY";
     ZoomMonthlyWeekDay[ZoomMonthlyWeekDay["MONDAY"] = 2] = "MONDAY";
     ZoomMonthlyWeekDay[ZoomMonthlyWeekDay["TUESDAY"] = 3] = "TUESDAY";
@@ -309,34 +653,28 @@ var ZoomMonthlyWeekDay;
     ZoomMonthlyWeekDay[ZoomMonthlyWeekDay["SATURDAY"] = 7] = "SATURDAY";
 })(ZoomMonthlyWeekDay || (ZoomMonthlyWeekDay = {}));
 var ZoomApprovalType;
-(function (ZoomApprovalType) {
+(function(ZoomApprovalType) {
     /**
      * Automatically approve.
-     */
-    ZoomApprovalType[ZoomApprovalType["AUTOMATICALLY_APPROVE"] = 0] = "AUTOMATICALLY_APPROVE";
+     */ ZoomApprovalType[ZoomApprovalType["AUTOMATICALLY_APPROVE"] = 0] = "AUTOMATICALLY_APPROVE";
     /**
      * Manually approve.
-     */
-    ZoomApprovalType[ZoomApprovalType["MANUALLY_APPROVE"] = 1] = "MANUALLY_APPROVE";
+     */ ZoomApprovalType[ZoomApprovalType["MANUALLY_APPROVE"] = 1] = "MANUALLY_APPROVE";
     /**
      * No registration required.
-     */
-    ZoomApprovalType[ZoomApprovalType["NO_REGISTRATION_REQUIRED"] = 2] = "NO_REGISTRATION_REQUIRED";
+     */ ZoomApprovalType[ZoomApprovalType["NO_REGISTRATION_REQUIRED"] = 2] = "NO_REGISTRATION_REQUIRED";
 })(ZoomApprovalType || (ZoomApprovalType = {}));
 var ZoomRegistrationType;
-(function (ZoomRegistrationType) {
+(function(ZoomRegistrationType) {
     /**
      * Attendees register once and can attend any meeting occurrence.
-     */
-    ZoomRegistrationType[ZoomRegistrationType["REGISTER_ONCE_ATTEND_ANY"] = 1] = "REGISTER_ONCE_ATTEND_ANY";
+     */ ZoomRegistrationType[ZoomRegistrationType["REGISTER_ONCE_ATTEND_ANY"] = 1] = "REGISTER_ONCE_ATTEND_ANY";
     /**
      * Attendees must register for each meeting occurrence.
-     */
-    ZoomRegistrationType[ZoomRegistrationType["REGISTER_FOR_EACH_OCCURRENCE"] = 2] = "REGISTER_FOR_EACH_OCCURRENCE";
+     */ ZoomRegistrationType[ZoomRegistrationType["REGISTER_FOR_EACH_OCCURRENCE"] = 2] = "REGISTER_FOR_EACH_OCCURRENCE";
     /**
      * Attendees register once and can select one or more meeting occurrences to attend.
-     */
-    ZoomRegistrationType[ZoomRegistrationType["REGISTER_ONCE_CHOOSE_OCCURRENCES"] = 3] = "REGISTER_ONCE_CHOOSE_OCCURRENCES";
+     */ ZoomRegistrationType[ZoomRegistrationType["REGISTER_ONCE_CHOOSE_OCCURRENCES"] = 3] = "REGISTER_ONCE_CHOOSE_OCCURRENCES";
 })(ZoomRegistrationType || (ZoomRegistrationType = {}));
 
 /**
@@ -344,45 +682,192 @@ var ZoomRegistrationType;
  *
  * @param context
  * @returns
- */
-function getUser(context) {
-    return (input) => context.fetchJson(`/users/${input.userId}`, 'GET');
+ */ function getUser(context) {
+    return function(input) {
+        return context.fetchJson("/users/".concat(input.userId), 'GET');
+    };
 }
 /**
  * https://developers.zoom.us/docs/api/users/#tag/users/GET/users
  *
  * @param context
  * @returns
- */
-function listUsers(context) {
-    return (input) => context.fetchJson(`/users?${makeUrlSearchParams(input)}`, 'GET').then(mapToZoomPageResult('users'));
+ */ function listUsers(context) {
+    return function(input) {
+        return context.fetchJson("/users?".concat(makeUrlSearchParams(input)), 'GET').then(mapToZoomPageResult('users'));
+    };
 }
 function listUsersPageFactory(context) {
     return zoomFetchPageFactory(listUsers(context));
 }
 
 var ZoomUserType;
-(function (ZoomUserType) {
+(function(ZoomUserType) {
     ZoomUserType[ZoomUserType["Basic"] = 1] = "Basic";
     ZoomUserType[ZoomUserType["Licensed"] = 2] = "Licensed";
     ZoomUserType[ZoomUserType["Unassigned"] = 4] = "Unassigned";
     ZoomUserType[ZoomUserType["None"] = 99] = "None";
 })(ZoomUserType || (ZoomUserType = {}));
 
-// MARK: Parser
-const logZoomErrorToConsole = logZoomServerErrorFunction('Zoom');
-async function parseZoomApiError(responseError) {
-    const data = await responseError.response.json().catch((x) => undefined);
-    let result;
-    if (data) {
-        result = parseZoomApiServerErrorResponseData(data, responseError);
+function asyncGeneratorStep$4(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
     }
-    return result;
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$4(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$4(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$4(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _ts_generator$4(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
+        };
+    }
+}
+// MARK: Parser
+var logZoomErrorToConsole = logZoomServerErrorFunction('Zoom');
+function parseZoomApiError(responseError) {
+    return _async_to_generator$4(function() {
+        var data, result;
+        return _ts_generator$4(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    return [
+                        4,
+                        responseError.response.json().catch(function(x) {
+                            return undefined;
+                        })
+                    ];
+                case 1:
+                    data = _state.sent();
+                    if (data) {
+                        result = parseZoomApiServerErrorResponseData(data, responseError);
+                    }
+                    return [
+                        2,
+                        result
+                    ];
+            }
+        });
+    })();
 }
 function parseZoomApiServerErrorResponseData(zoomServerError, responseError) {
-    let result;
+    var result;
     if (zoomServerError) {
-        switch (zoomServerError.code) {
+        switch(zoomServerError.code){
             default:
                 result = parseZoomServerErrorData(zoomServerError, responseError);
                 break;
@@ -390,48 +875,274 @@ function parseZoomApiServerErrorResponseData(zoomServerError, responseError) {
     }
     return result;
 }
-const handleZoomErrorFetch = handleZoomErrorFetchFactory(parseZoomApiError, logZoomErrorToConsole);
+var handleZoomErrorFetch = handleZoomErrorFetchFactory(parseZoomApiError, logZoomErrorToConsole);
 
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function asyncGeneratorStep$3(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$3(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _call_super(_this, derived, args) {
+    derived = _get_prototype_of(derived);
+    return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+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;
+    }
+    return obj;
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct = function() {
+        return !!result;
+    })();
+}
+function _ts_generator$3(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
+        };
+    }
+}
 /**
  * Error in the following cases:
  * - the refresh token string is invalid
- */
-const ZOOM_ACCOUNTS_INVALID_GRANT_ERROR_CODE = 'invalid_grant';
+ */ var ZOOM_ACCOUNTS_INVALID_GRANT_ERROR_CODE = 'invalid_grant';
 /**
  * Thrown if the call to the Zoom API creating an access token using a refresh token fails.
- */
-class ZoomOAuthAccessTokenError extends FetchRequestFactoryError {
-    errorCode;
-    constructor(errorCode) {
-        super(`ZoomOAuthAccessTokenError: ${errorCode}`);
-        this.errorCode = errorCode;
+ */ var ZoomOAuthAccessTokenError = /*#__PURE__*/ function(FetchRequestFactoryError) {
+    _inherits(ZoomOAuthAccessTokenError, FetchRequestFactoryError);
+    function ZoomOAuthAccessTokenError(errorCode) {
+        _class_call_check(this, ZoomOAuthAccessTokenError);
+        var _this;
+        _this = _call_super(this, ZoomOAuthAccessTokenError, [
+            "ZoomOAuthAccessTokenError: ".concat(errorCode)
+        ]), _define_property(_this, "errorCode", void 0);
+        _this.errorCode = errorCode;
+        return _this;
     }
-}
+    return ZoomOAuthAccessTokenError;
+}(FetchRequestFactoryError);
 /**
  * Thrown if a valid ZoomAccessToken cannot be retrieved successfully.
- */
-class ZoomOAuthAuthFailureError extends FetchRequestFactoryError {
-    reason;
-    constructor(reason) {
-        super(`Failed to retrieve proper authentication for the API call. Reason: ${reason}`);
-        this.reason = reason;
-    }
-}
-const logZoomOAuthErrorToConsole = logZoomServerErrorFunction('ZoomOAuth');
-async function parseZoomOAuthError(responseError) {
-    const data = await responseError.response.json().catch((x) => undefined);
-    let result;
-    if (data) {
-        result = parseZoomOAuthServerErrorResponseData(data, responseError);
+ */ var ZoomOAuthAuthFailureError = /*#__PURE__*/ function(FetchRequestFactoryError) {
+    _inherits(ZoomOAuthAuthFailureError, FetchRequestFactoryError);
+    function ZoomOAuthAuthFailureError(reason) {
+        _class_call_check(this, ZoomOAuthAuthFailureError);
+        var _this;
+        _this = _call_super(this, ZoomOAuthAuthFailureError, [
+            "Failed to retrieve proper authentication for the API call. Reason: ".concat(reason)
+        ]), _define_property(_this, "reason", void 0);
+        _this.reason = reason;
+        return _this;
     }
-    return result;
+    return ZoomOAuthAuthFailureError;
+}(FetchRequestFactoryError);
+var logZoomOAuthErrorToConsole = logZoomServerErrorFunction('ZoomOAuth');
+function parseZoomOAuthError(responseError) {
+    return _async_to_generator$3(function() {
+        var data, result;
+        return _ts_generator$3(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    return [
+                        4,
+                        responseError.response.json().catch(function(x) {
+                            return undefined;
+                        })
+                    ];
+                case 1:
+                    data = _state.sent();
+                    if (data) {
+                        result = parseZoomOAuthServerErrorResponseData(data, responseError);
+                    }
+                    return [
+                        2,
+                        result
+                    ];
+            }
+        });
+    })();
 }
 function parseZoomOAuthServerErrorResponseData(zoomServerError, responseError) {
-    let result;
+    var result;
     if (zoomServerError) {
-        const potentialErrorStringCode = zoomServerError.error;
-        const errorCode = potentialErrorStringCode ?? zoomServerError.code;
-        switch (errorCode) {
+        var potentialErrorStringCode = zoomServerError.error;
+        var errorCode = potentialErrorStringCode !== null && potentialErrorStringCode !== void 0 ? potentialErrorStringCode : zoomServerError.code;
+        switch(errorCode){
             case ZOOM_ACCOUNTS_INVALID_GRANT_ERROR_CODE:
                 result = new ZoomOAuthAccessTokenError(errorCode);
                 break;
@@ -442,28 +1153,172 @@ function parseZoomOAuthServerErrorResponseData(zoomServerError, responseError) {
     }
     return result;
 }
-const handleZoomOAuthErrorFetch = handleZoomErrorFetchFactory(parseZoomOAuthError, logZoomOAuthErrorToConsole);
+var handleZoomOAuthErrorFetch = handleZoomErrorFetchFactory(parseZoomOAuthError, logZoomOAuthErrorToConsole);
 
+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 _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
+        };
+    }
+}
 /**
  * Generates a new ZoomAccessTokenStringFactory.
- */
-function zoomAccessTokenStringFactory(zoomAccessTokenFactory) {
-    return async () => {
-        const token = await zoomAccessTokenFactory();
-        if (!token?.accessToken) {
-            throw new ZoomOAuthAuthFailureError();
-        }
-        return token.accessToken;
+ */ function zoomAccessTokenStringFactory(zoomAccessTokenFactory) {
+    return function() {
+        return _async_to_generator$2(function() {
+            var token;
+            return _ts_generator$2(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        return [
+                            4,
+                            zoomAccessTokenFactory()
+                        ];
+                    case 1:
+                        token = _state.sent();
+                        if (!(token === null || token === void 0 ? void 0 : token.accessToken)) {
+                            throw new ZoomOAuthAuthFailureError();
+                        }
+                        return [
+                            2,
+                            token.accessToken
+                        ];
+                }
+            });
+        })();
     };
 }
 
-const DEFAULT_ZOOM_RATE_LIMITED_TOO_MANY_REQUETS_LOG_FUNCTION = (headers) => {
-    console.warn(`zoomRateLimitedFetchHandler(): Too many requests made. The limit is ${headers.limit} requests per reset period. RetryAt is set for ${headers.retryAfterAt}.`);
+var DEFAULT_ZOOM_RATE_LIMITED_TOO_MANY_REQUETS_LOG_FUNCTION = function DEFAULT_ZOOM_RATE_LIMITED_TOO_MANY_REQUETS_LOG_FUNCTION(headers) {
+    console.warn("zoomRateLimitedFetchHandler(): Too many requests made. The limit is ".concat(headers.limit, " requests per reset period. RetryAt is set for ").concat(headers.retryAfterAt, "."));
 };
 function zoomRateLimitedFetchHandler(config) {
-    const onTooManyRequests = config?.onTooManyRequests !== false ? (config?.onTooManyRequests ?? DEFAULT_ZOOM_RATE_LIMITED_TOO_MANY_REQUETS_LOG_FUNCTION) : undefined;
-    const defaultLimit = config?.maxRateLimit ?? DEFAULT_ZOOM_API_RATE_LIMIT;
-    const defaultResetPeriod = config?.resetPeriod ?? DEFAULT_ZOOM_API_RATE_LIMIT_RESET_PERIOD;
+    var _ref, _ref1, _ref2;
+    var onTooManyRequests = (config === null || config === void 0 ? void 0 : config.onTooManyRequests) !== false ? (_ref = config === null || config === void 0 ? void 0 : config.onTooManyRequests) !== null && _ref !== void 0 ? _ref : DEFAULT_ZOOM_RATE_LIMITED_TOO_MANY_REQUETS_LOG_FUNCTION : undefined;
+    var defaultLimit = (_ref1 = config === null || config === void 0 ? void 0 : config.maxRateLimit) !== null && _ref1 !== void 0 ? _ref1 : DEFAULT_ZOOM_API_RATE_LIMIT;
+    var defaultResetPeriod = (_ref2 = config === null || config === void 0 ? void 0 : config.resetPeriod) !== null && _ref2 !== void 0 ? _ref2 : DEFAULT_ZOOM_API_RATE_LIMIT_RESET_PERIOD;
     function configForLimit(limit, resetAt) {
         return {
             limit: defaultLimit,
@@ -472,41 +1327,40 @@ function zoomRateLimitedFetchHandler(config) {
             exponentRate: 1.2,
             maxWaitTime: MS_IN_SECOND * 5,
             resetPeriod: defaultResetPeriod,
-            resetAt
+            resetAt: resetAt
         };
     }
-    const defaultConfig = configForLimit();
-    const rateLimiter = resetPeriodPromiseRateLimiter(defaultConfig);
+    var defaultConfig = configForLimit();
+    var rateLimiter = resetPeriodPromiseRateLimiter(defaultConfig);
     return rateLimitedFetchHandler({
-        rateLimiter,
-        updateWithResponse: function (response, fetchResponseError) {
-            const hasLimitHeader = response.headers.has(ZOOM_RATE_LIMIT_REMAINING_HEADER);
-            let shouldRetry = false;
+        rateLimiter: rateLimiter,
+        updateWithResponse: function updateWithResponse(response, fetchResponseError) {
+            var hasLimitHeader = response.headers.has(ZOOM_RATE_LIMIT_REMAINING_HEADER);
+            var shouldRetry = false;
             // let enabled = false;   // rate limiter should not be turned off
             if (hasLimitHeader) {
-                const headerDetails = zoomRateLimitHeaderDetails(response.headers);
+                var headerDetails = zoomRateLimitHeaderDetails(response.headers);
                 if (headerDetails) {
-                    const { type, limit, retryAfterAt, remaining } = headerDetails;
+                    var type = headerDetails.type, limit = headerDetails.limit, retryAfterAt = headerDetails.retryAfterAt, remaining = headerDetails.remaining;
                     if (response.status === ZOOM_TOO_MANY_REQUESTS_HTTP_STATUS_CODE) {
                         // For simple query-per-second rate limits, just schedule a retry
                         if (type === 'QPS') {
                             shouldRetry = true;
                             try {
-                                onTooManyRequests?.(headerDetails, response, fetchResponseError);
-                            }
-                            catch (e) { }
+                                onTooManyRequests === null || onTooManyRequests === void 0 ? void 0 : onTooManyRequests(headerDetails, response, fetchResponseError);
+                            } catch (e) {}
                         }
                     }
                     // NOTE: typically it seems like these headers are not available usually.
                     // There is a daily limit for message requests
                     if (limit != null && retryAfterAt != null && remaining != null) {
                         if (limit !== defaultLimit) {
-                            const newConfig = configForLimit(limit, retryAfterAt);
+                            var newConfig = configForLimit(limit, retryAfterAt);
                             rateLimiter.setConfig(newConfig, false);
                         }
                         rateLimiter.setRemainingLimit(remaining);
                         rateLimiter.setNextResetAt(retryAfterAt);
-                        // enabled = true;
+                    // enabled = true;
                     }
                 }
             }
@@ -518,69 +1372,218 @@ function zoomRateLimitedFetchHandler(config) {
 
 /**
  * The Zoom API URL for the US datacenter.
- */
-const ZOOM_API_URL = 'https://api.zoom.us/v2';
+ */ var ZOOM_API_URL = 'https://api.zoom.us/v2';
 
-function zoomFactory(factoryConfig) {
-    const { oauthContext } = factoryConfig;
-    const serverAccessTokenStringFactory = zoomAccessTokenStringFactory(oauthContext.loadAccessToken);
-    const fetchHandler = zoomRateLimitedFetchHandler(factoryConfig.rateLimiterConfig);
-    const { logZoomServerErrorFunction, fetchFactory = (input) => fetchApiFetchService.makeFetch({
-        baseUrl: ZOOM_API_URL,
-        baseRequest: async () => ({
-            headers: {
-                'Content-Type': 'application/json',
-                Authorization: `Bearer ${await input.zoomAccessTokenStringFactory()}`
+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;
+    }
+    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 _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;
+        }
+    }), 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;
             }
-        }),
-        fetchHandler,
-        timeout: 20 * 1000, // 20 second timeout
-        requireOkResponse: true, // enforce ok response
-        useTimeout: true // use timeout
-    }) } = factoryConfig;
-    return (config) => {
-        const baseFetch = fetchFactory({
+            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
+        };
+    }
+}
+function zoomFactory(factoryConfig) {
+    var oauthContext = factoryConfig.oauthContext;
+    var serverAccessTokenStringFactory = zoomAccessTokenStringFactory(oauthContext.loadAccessToken);
+    var fetchHandler = zoomRateLimitedFetchHandler(factoryConfig.rateLimiterConfig);
+    var logZoomServerErrorFunction = factoryConfig.logZoomServerErrorFunction, _factoryConfig_fetchFactory = factoryConfig.fetchFactory, fetchFactory = _factoryConfig_fetchFactory === void 0 ? function(input) {
+        return fetchApiFetchService.makeFetch({
+            baseUrl: ZOOM_API_URL,
+            baseRequest: function baseRequest() {
+                return _async_to_generator$1(function() {
+                    var _tmp, _tmp1, _, _1;
+                    return _ts_generator$1(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                _tmp = {};
+                                _tmp1 = {
+                                    'Content-Type': 'application/json'
+                                };
+                                _1 = (_ = "Bearer ").concat;
+                                return [
+                                    4,
+                                    input.zoomAccessTokenStringFactory()
+                                ];
+                            case 1:
+                                return [
+                                    2,
+                                    (_tmp.headers = (_tmp1.Authorization = _1.apply(_, [
+                                        _state.sent()
+                                    ]), _tmp1), _tmp)
+                                ];
+                        }
+                    });
+                })();
+            },
+            fetchHandler: fetchHandler,
+            timeout: 20 * 1000,
+            requireOkResponse: true,
+            useTimeout: true // use timeout
+        });
+    } : _factoryConfig_fetchFactory;
+    return function(config) {
+        var baseFetch = fetchFactory({
             zoomAccessTokenStringFactory: serverAccessTokenStringFactory
         });
-        const serverFetch = handleZoomErrorFetch(baseFetch, logZoomServerErrorFunction);
-        const serverFetchJson = fetchJsonFunction(serverFetch, {
+        var serverFetch = handleZoomErrorFetch(baseFetch, logZoomServerErrorFunction);
+        var serverFetchJson = fetchJsonFunction(serverFetch, {
             handleFetchJsonParseErrorFunction: returnNullHandleFetchJsonParseErrorFunction
         });
         // MARK: Make User Context
-        const makeUserContext = (input) => {
-            const userAccessTokenFactory = oauthContext.makeUserAccessTokenFactory({
+        var makeUserContext = function makeUserContext(input) {
+            var userAccessTokenFactory = oauthContext.makeUserAccessTokenFactory({
                 refreshToken: input.refreshToken,
                 userAccessTokenCache: input.accessTokenCache
             });
-            const userAccessTokenStringFactory = zoomAccessTokenStringFactory(userAccessTokenFactory);
-            const userFetch = fetchFactory({
+            var userAccessTokenStringFactory = zoomAccessTokenStringFactory(userAccessTokenFactory);
+            var userFetch = fetchFactory({
                 zoomAccessTokenStringFactory: userAccessTokenStringFactory
             });
-            const userFetchJson = fetchJsonFunction(userFetch, {
+            var userFetchJson = fetchJsonFunction(userFetch, {
                 handleFetchJsonParseErrorFunction: returnNullHandleFetchJsonParseErrorFunction
             });
-            const result = {
+            var result = {
                 zoomServerContext: zoomContext,
                 type: 'user',
                 fetch: userFetch,
                 fetchJson: userFetchJson,
-                userFetch,
-                userFetchJson,
+                userFetch: userFetch,
+                userFetchJson: userFetchJson,
                 zoomRateLimiter: fetchHandler._rateLimiter
             };
             return result;
         };
-        const zoomContext = {
+        var zoomContext = {
             type: 'server',
             fetch: serverFetch,
             fetchJson: serverFetchJson,
-            serverFetch,
-            serverFetchJson,
-            makeUserContext,
-            config,
+            serverFetch: serverFetch,
+            serverFetchJson: serverFetchJson,
+            makeUserContext: makeUserContext,
+            config: config,
             zoomRateLimiter: fetchHandler._rateLimiter
         };
-        const zoom = {
+        var zoom = {
             zoomServerContext: zoomContext
         };
         return zoom;
@@ -592,10 +1595,10 @@ function zoomFactory(factoryConfig) {
  *
  * @param context
  * @returns
- */
-function serverAccessToken(context) {
-    return (input) => {
-        return context.fetchJson(`/token?grant_type=account_credentials&account_id=${input?.accountId ?? context.config.accountId}`, zoomOAuthApiFetchJsonInput(context, input));
+ */ function serverAccessToken(context) {
+    return function(input) {
+        var _ref;
+        return context.fetchJson("/token?grant_type=account_credentials&account_id=".concat((_ref = input === null || input === void 0 ? void 0 : input.accountId) !== null && _ref !== void 0 ? _ref : context.config.accountId), zoomOAuthApiFetchJsonInput(context, input));
     };
 }
 /**
@@ -603,21 +1606,22 @@ function serverAccessToken(context) {
  *
  * @param context
  * @returns
- */
-function userAccessToken(context) {
-    return (input) => {
-        const refreshToken = input.refreshToken;
-        return context.fetchJson(`/token?grant_type=refresh_token&refresh_token=${refreshToken}`, zoomOAuthApiFetchJsonInput(context, input));
+ */ function userAccessToken(context) {
+    return function(input) {
+        var refreshToken = input.refreshToken;
+        return context.fetchJson("/token?grant_type=refresh_token&refresh_token=".concat(refreshToken), zoomOAuthApiFetchJsonInput(context, input));
     };
 }
 function zoomOAuthApiFetchJsonInput(context, input) {
-    const clientId = input?.client?.clientId ?? context.config.clientId;
-    const clientSecret = input?.client?.clientSecret ?? context.config.clientSecret;
-    const fetchJsonInput = {
+    var _ref, _ref1;
+    var _input_client, _input_client1;
+    var clientId = (_ref = input === null || input === void 0 ? void 0 : (_input_client = input.client) === null || _input_client === void 0 ? void 0 : _input_client.clientId) !== null && _ref !== void 0 ? _ref : context.config.clientId;
+    var clientSecret = (_ref1 = input === null || input === void 0 ? void 0 : (_input_client1 = input.client) === null || _input_client1 === void 0 ? void 0 : _input_client1.clientSecret) !== null && _ref1 !== void 0 ? _ref1 : context.config.clientSecret;
+    var fetchJsonInput = {
         headers: {
             Authorization: zoomOAuthServerBasicAuthorizationHeaderValue({
-                clientId,
-                clientSecret
+                clientId: clientId,
+                clientSecret: clientSecret
             })
         },
         method: 'POST'
@@ -625,83 +1629,242 @@ function zoomOAuthApiFetchJsonInput(context, input) {
     return fetchJsonInput;
 }
 function zoomOAuthServerBasicAuthorizationHeaderValue(input) {
-    return `Basic ${Buffer.from(`${input.clientId}:${input.clientSecret}`).toString('base64')}`;
+    return "Basic ".concat(Buffer.from("".concat(input.clientId, ":").concat(input.clientSecret)).toString('base64'));
 }
 
 /**
  * The Zoom OAuth API URL for the US datacenter.
- */
-const ZOOM_OAUTH_API_URL = 'https://zoom.us/oauth';
+ */ var ZOOM_OAUTH_API_URL = 'https://zoom.us/oauth';
 
-function zoomOAuthFactory(factoryConfig) {
-    const fetchHandler = zoomRateLimitedFetchHandler();
-    const { logZoomServerErrorFunction, fetchFactory = (_) => fetchApiFetchService.makeFetch({
-        baseUrl: ZOOM_OAUTH_API_URL,
-        baseRequest: {
-            headers: {
-                'Content-Type': 'application/json'
+function asyncGeneratorStep(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(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 _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
         },
-        fetchHandler,
-        timeout: 20 * 1000, // 20 second timeout
-        requireOkResponse: true, // enforce ok response
-        useTimeout: true // use timeout
-    }) } = factoryConfig;
-    return (config) => {
-        if (!config.clientId) {
-            throw new Error('ZoomOAuthConfig missing clientId.');
-        }
-        else if (!config.clientSecret) {
-            throw new Error('ZoomOAuthConfig missing clientSecret.');
+        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 if (!config.accountId) {
-            throw new Error('ZoomOAuthConfig missing accountId.');
+    }), 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;
         }
-        const baseFetch = fetchFactory();
-        const fetch = handleZoomOAuthErrorFetch(baseFetch, logZoomServerErrorFunction);
-        const fetchJson = fetchJsonFunction(fetch, {
-            handleFetchJsonParseErrorFunction: returnNullHandleFetchJsonParseErrorFunction
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+function zoomOAuthFactory(factoryConfig) {
+    var fetchHandler = zoomRateLimitedFetchHandler();
+    var logZoomServerErrorFunction = factoryConfig.logZoomServerErrorFunction, _factoryConfig_fetchFactory = factoryConfig.fetchFactory, fetchFactory = _factoryConfig_fetchFactory === void 0 ? function(_) {
+        return fetchApiFetchService.makeFetch({
+            baseUrl: ZOOM_OAUTH_API_URL,
+            baseRequest: {
+                headers: {
+                    'Content-Type': 'application/json'
+                }
+            },
+            fetchHandler: fetchHandler,
+            timeout: 20 * 1000,
+            requireOkResponse: true,
+            useTimeout: true // use timeout
         });
-        function accessTokenFromTokenResponse(result) {
-            const createdAt = new Date().getTime();
-            const { access_token, api_url, scope, expires_in } = result;
-            const accessToken = {
+    } : _factoryConfig_fetchFactory;
+    return function(config) {
+        var accessTokenFromTokenResponse = function accessTokenFromTokenResponse(result) {
+            var createdAt = new Date().getTime();
+            var access_token = result.access_token, api_url = result.api_url, scope = result.scope, expires_in = result.expires_in;
+            var accessToken = {
                 accessToken: access_token,
                 apiDomain: api_url,
                 expiresIn: expires_in,
                 expiresAt: new Date(createdAt + expires_in * MS_IN_SECOND),
-                scope
+                scope: scope
             };
             return accessToken;
+        };
+        if (!config.clientId) {
+            throw new Error('ZoomOAuthConfig missing clientId.');
+        } else if (!config.clientSecret) {
+            throw new Error('ZoomOAuthConfig missing clientSecret.');
+        } else if (!config.accountId) {
+            throw new Error('ZoomOAuthConfig missing accountId.');
         }
-        const tokenRefresher = async () => {
-            const accessToken = await serverAccessToken(oauthContext)();
-            return accessTokenFromTokenResponse(accessToken);
+        var baseFetch = fetchFactory();
+        var fetch = handleZoomOAuthErrorFetch(baseFetch, logZoomServerErrorFunction);
+        var fetchJson = fetchJsonFunction(fetch, {
+            handleFetchJsonParseErrorFunction: returnNullHandleFetchJsonParseErrorFunction
+        });
+        var tokenRefresher = function tokenRefresher() {
+            return _async_to_generator(function() {
+                var accessToken;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            return [
+                                4,
+                                serverAccessToken(oauthContext)()
+                            ];
+                        case 1:
+                            accessToken = _state.sent();
+                            return [
+                                2,
+                                accessTokenFromTokenResponse(accessToken)
+                            ];
+                    }
+                });
+            })();
         };
-        const loadAccessToken = zoomOAuthZoomAccessTokenFactory({
-            tokenRefresher,
+        var loadAccessToken = zoomOAuthZoomAccessTokenFactory({
+            tokenRefresher: tokenRefresher,
             accessTokenCache: config.accessTokenCache
         });
         // User Access Token
-        const makeUserAccessTokenFactory = (input) => {
-            const userTokenRefresher = async () => {
-                const accessToken = await userAccessToken(oauthContext)(input);
-                return accessTokenFromTokenResponse(accessToken);
+        var makeUserAccessTokenFactory = function makeUserAccessTokenFactory(input) {
+            var userTokenRefresher = function userTokenRefresher() {
+                return _async_to_generator(function() {
+                    var accessToken;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    userAccessToken(oauthContext)(input)
+                                ];
+                            case 1:
+                                accessToken = _state.sent();
+                                return [
+                                    2,
+                                    accessTokenFromTokenResponse(accessToken)
+                                ];
+                        }
+                    });
+                })();
             };
             return zoomOAuthZoomAccessTokenFactory({
                 tokenRefresher: userTokenRefresher,
                 accessTokenCache: input.userAccessTokenCache
             });
         };
-        const oauthContext = {
-            fetch,
-            fetchJson,
-            loadAccessToken,
-            makeUserAccessTokenFactory,
-            config
+        var oauthContext = {
+            fetch: fetch,
+            fetchJson: fetchJson,
+            loadAccessToken: loadAccessToken,
+            makeUserAccessTokenFactory: makeUserAccessTokenFactory,
+            config: config
         };
-        const zoomOAuth = {
-            oauthContext
+        var zoomOAuth = {
+            oauthContext: oauthContext
         };
         return zoomOAuth;
     };
@@ -711,48 +1874,103 @@ function zoomOAuthFactory(factoryConfig) {
  *
  * @param config
  * @returns
- */
-function zoomOAuthZoomAccessTokenFactory(config) {
-    const { tokenRefresher, accessTokenCache, tokenExpirationBuffer: inputTokenExpirationBuffer } = config;
-    const tokenExpirationBuffer = inputTokenExpirationBuffer ?? MS_IN_MINUTE;
+ */ function zoomOAuthZoomAccessTokenFactory(config) {
+    var tokenRefresher = config.tokenRefresher, accessTokenCache = config.accessTokenCache, inputTokenExpirationBuffer = config.tokenExpirationBuffer;
+    var tokenExpirationBuffer = inputTokenExpirationBuffer !== null && inputTokenExpirationBuffer !== void 0 ? inputTokenExpirationBuffer : MS_IN_MINUTE;
     /**
      * Caches the token internally here until it expires.
-     */
-    let currentToken = null;
-    return async () => {
-        // load from cache
-        if (!currentToken) {
-            const cachedToken = await accessTokenCache?.loadCachedToken();
-            if (cachedToken) {
-                currentToken = cachedToken;
-            }
-        }
-        // check expiration
-        if (currentToken != null) {
-            const isExpired = new Date().getTime() + tokenExpirationBuffer >= currentToken.expiresAt.getTime();
-            if (isExpired) {
-                currentToken = null;
-            }
-        }
-        // load from source
-        if (!currentToken) {
-            try {
-                currentToken = await tokenRefresher();
-            }
-            catch (e) {
-                console.error(`zoomOAuthZoomAccessTokenFactory(): Failed retrieving new token from tokenRefresher: `, e);
-                throw new ZoomOAuthAuthFailureError('Token Refresh Failed');
-            }
-            if (currentToken) {
-                try {
-                    await accessTokenCache?.updateCachedToken(currentToken);
-                }
-                catch (e) {
-                    // do nothing
+     */ var currentToken = null;
+    return function() {
+        return _async_to_generator(function() {
+            var cachedToken, isExpired, e;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        if (!!currentToken) return [
+                            3,
+                            2
+                        ];
+                        return [
+                            4,
+                            accessTokenCache === null || accessTokenCache === void 0 ? void 0 : accessTokenCache.loadCachedToken()
+                        ];
+                    case 1:
+                        cachedToken = _state.sent();
+                        if (cachedToken) {
+                            currentToken = cachedToken;
+                        }
+                        _state.label = 2;
+                    case 2:
+                        // check expiration
+                        if (currentToken != null) {
+                            isExpired = new Date().getTime() + tokenExpirationBuffer >= currentToken.expiresAt.getTime();
+                            if (isExpired) {
+                                currentToken = null;
+                            }
+                        }
+                        if (!!currentToken) return [
+                            3,
+                            10
+                        ];
+                        _state.label = 3;
+                    case 3:
+                        _state.trys.push([
+                            3,
+                            5,
+                            ,
+                            6
+                        ]);
+                        return [
+                            4,
+                            tokenRefresher()
+                        ];
+                    case 4:
+                        currentToken = _state.sent();
+                        return [
+                            3,
+                            6
+                        ];
+                    case 5:
+                        e = _state.sent();
+                        console.error("zoomOAuthZoomAccessTokenFactory(): Failed retrieving new token from tokenRefresher: ", e);
+                        throw new ZoomOAuthAuthFailureError('Token Refresh Failed');
+                    case 6:
+                        if (!currentToken) return [
+                            3,
+                            10
+                        ];
+                        _state.label = 7;
+                    case 7:
+                        _state.trys.push([
+                            7,
+                            9,
+                            ,
+                            10
+                        ]);
+                        return [
+                            4,
+                            accessTokenCache === null || accessTokenCache === void 0 ? void 0 : accessTokenCache.updateCachedToken(currentToken)
+                        ];
+                    case 8:
+                        _state.sent();
+                        return [
+                            3,
+                            10
+                        ];
+                    case 9:
+                        _state.sent();
+                        return [
+                            3,
+                            10
+                        ];
+                    case 10:
+                        return [
+                            2,
+                            currentToken
+                        ];
                 }
-            }
-        }
-        return currentToken;
+            });
+        })();
     };
 }