@dereekb/zoom 13.0.0 → 13.0.2

package/index.cjs.js

@@ -1,10 +1,6 @@
 'use strict';
 
-require('core-js/modules/es.json.stringify.js');
 var fetch = require('@dereekb/util/fetch');
-require('core-js/modules/es.set.difference.v2.js');
-require('core-js/modules/es.set.symmetric-difference.v2.js');
-require('core-js/modules/es.set.union.v2.js');
 var util = require('@dereekb/util');
 var makeError = require('make-error');
 
@@ -17,23 +13,17 @@ var makeError = require('make-error');
  * @returns
  */
 function mapToZoomPageResult(dataTypeKey) {
-  return data => {
-    const {
-      next_page_token,
-      page_count,
-      page_number,
-      page_size,
-      total_records
-    } = data;
-    return {
-      data: data[dataTypeKey],
-      next_page_token,
-      page_count,
-      page_number,
-      page_size,
-      total_records
+    return (data) => {
+        const { next_page_token, page_count, page_number, page_size, total_records } = data;
+        return {
+            data: data[dataTypeKey],
+            next_page_token,
+            page_count,
+            page_number,
+            page_size,
+            total_records
+        };
     };
-  };
 }
 /**
  * Creates a FetchPageFactory using the input ZoomFetchPageFetchFunction.
@@ -43,23 +33,19 @@ function mapToZoomPageResult(dataTypeKey) {
  * @returns
  */
 function zoomFetchPageFactory(fetch$1, defaults) {
-  return fetch.fetchPageFactory({
-    ...defaults,
-    fetch: fetch$1,
-    readFetchPageResultInfo: function (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
-      };
-    }
-  });
+    return fetch.fetchPageFactory({
+        ...defaults,
+        fetch: fetch$1,
+        readFetchPageResultInfo: function (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 };
+        }
+    });
 }
 
 /**
@@ -70,26 +56,26 @@ const ZOOM_SUCCESS_CODE = 'SUCCESS';
  * Zoom Server Error
  */
 class ZoomServerError extends makeError.BaseError {
-  get code() {
-    return this.error.code;
-  }
-  constructor(error) {
-    super(error.message);
-    this.error = void 0;
-    this.error = error;
-  }
+    error;
+    get code() {
+        return this.error.code;
+    }
+    constructor(error) {
+        super(error.message);
+        this.error = error;
+    }
 }
 /**
  * Zoom Server Error that includes the FetchResponseError
  */
 class ZoomServerFetchResponseError extends ZoomServerError {
-  constructor(data, responseError) {
-    super(data);
-    this.data = void 0;
-    this.responseError = void 0;
-    this.data = data;
-    this.responseError = responseError;
-  }
+    data;
+    responseError;
+    constructor(data, responseError) {
+        super(data);
+        this.data = data;
+        this.responseError = responseError;
+    }
 }
 /**
  * Creates a logZoomServerErrorFunction that logs the error to console.
@@ -98,22 +84,17 @@ class ZoomServerFetchResponseError extends ZoomServerError {
  * @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
-      });
-    }
-  };
+    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 });
+        }
+    };
 }
 /**
  * Wraps a ConfiguredFetch to support handling errors returned by fetch.
@@ -122,22 +103,23 @@ function logZoomServerErrorFunction(zoomApiNamePrefix) {
  * @returns
  */
 function handleZoomErrorFetchFactory(parseZoomError, defaultLogError) {
-  return (fetch$1, logError = defaultLogError) => {
-    return async (x, y) => {
-      try {
-        return await fetch$1(x, y); // await to catch thrown errors
-      } catch (e) {
-        if (e instanceof fetch.FetchResponseError) {
-          const error = await parseZoomError(e);
-          if (error) {
-            logError(error); // log before throwing.
-            throw error;
-          }
-        }
-        throw e;
-      }
+    return (fetch$1, logError = defaultLogError) => {
+        return async (x, y) => {
+            try {
+                return await fetch$1(x, y); // await to catch thrown errors
+            }
+            catch (e) {
+                if (e instanceof fetch.FetchResponseError) {
+                    const error = await parseZoomError(e);
+                    if (error) {
+                        logError(error); // log before throwing.
+                        throw error;
+                    }
+                }
+                throw e;
+            }
+        };
     };
-  };
 }
 // MARK: Parsed Errors
 /**
@@ -156,34 +138,27 @@ const ZOOM_RATE_LIMIT_RETRY_AFTER_HEADER = 'Retry-After';
 const DEFAULT_ZOOM_API_RATE_LIMIT = 2;
 const DEFAULT_ZOOM_API_RATE_LIMIT_RESET_PERIOD = util.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;
-  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
-    };
-  }
-  return result;
+    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;
+    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 };
+    }
+    return result;
 }
 class ZoomTooManyRequestsError extends ZoomServerFetchResponseError {
-  get headerDetails() {
-    return zoomRateLimitHeaderDetails(this.responseError.response.headers);
-  }
+    get headerDetails() {
+        return zoomRateLimitHeaderDetails(this.responseError.response.headers);
+    }
 }
 /**
  * Function that parses/transforms a ZoomServerErrorData into a general ZoomServerError or other known error type.
@@ -193,22 +168,23 @@ class ZoomTooManyRequestsError extends ZoomServerFetchResponseError {
  * @returns
  */
 function parseZoomServerErrorData(zoomServerError, responseError) {
-  let result;
-  if (responseError.response.status === ZOOM_TOO_MANY_REQUESTS_HTTP_STATUS_CODE) {
-    result = new ZoomTooManyRequestsError(zoomServerError, responseError);
-    console.warn('ZoomTooManyRequestsError', {
-      result,
-      responseError,
-      headerDetails: result.headerDetails
-    });
-  } else if (zoomServerError) {
-    switch (zoomServerError.code) {
-      default:
-        result = new ZoomServerFetchResponseError(zoomServerError, responseError);
-        break;
+    let result;
+    if (responseError.response.status === ZOOM_TOO_MANY_REQUESTS_HTTP_STATUS_CODE) {
+        result = new ZoomTooManyRequestsError(zoomServerError, responseError);
+        console.warn('ZoomTooManyRequestsError', {
+            result,
+            responseError,
+            headerDetails: result.headerDetails
+        });
     }
-  }
-  return result;
+    else if (zoomServerError) {
+        switch (zoomServerError.code) {
+            default:
+                result = new ZoomServerFetchResponseError(zoomServerError, responseError);
+                break;
+        }
+    }
+    return result;
 }
 /**
  * Returns a pre-configured MakeUrlSearchParamsOptions that omits the silenceError key.
@@ -216,84 +192,80 @@ function parseZoomServerErrorData(zoomServerError, responseError) {
  * 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 fetch.mergeMakeUrlSearchParamsOptions([options, {
-    omitKeys
-  }]);
+    const omitKeys = ['silenceError'];
+    return fetch.mergeMakeUrlSearchParamsOptions([options, { omitKeys }]);
 }
 function silenceZoomErrorWithCodesFunction(codes, returnFn) {
-  const codesSet = new Set(util.asArray(codes));
-  return silence => {
-    return reason => {
-      if (silence !== false && reason instanceof ZoomServerFetchResponseError) {
-        if (codesSet.has(reason.code)) {
-          return returnFn?.(reason);
-        }
-      }
-      throw reason;
+    const codesSet = new Set(util.asArray(codes));
+    return (silence) => {
+        return (reason) => {
+            if (silence !== false && reason instanceof ZoomServerFetchResponseError) {
+                if (codesSet.has(reason.code)) {
+                    return returnFn?.(reason);
+                }
+            }
+            throw reason;
+        };
     };
-  };
 }
 
 /**
  * https://developers.zoom.us/docs/api/rest/reference/zoom-api/methods/#operation/meeting
  */
 function getMeeting(context) {
-  return input => context.fetchJson(`/meetings/${input.meetingId}`, 'GET');
+    return (input) => context.fetchJson(`/meetings/${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'));
+    return (input) => context.fetchJson(`/users/${input.user}/meetings`, 'GET').then(mapToZoomPageResult('meetings'));
 }
 function listMeetingsForUserPageFactory(context) {
-  return zoomFetchPageFactory(listMeetingsForUser(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`, {
-      method: 'POST',
-      body: JSON.stringify(input.template)
-    });
-  };
+    return (input) => {
+        return context.fetchJson(`/users/${input.user}/meetings`, {
+            method: 'POST',
+            body: JSON.stringify(input.template)
+        });
+    };
 }
 /**
  * https://developers.zoom.us/docs/api/meetings/#tag/meetings/PUT/meetings/{meetingId}
  */
 function updateMeeting(context) {
-  return input => context.fetchJson(`/meetings/${input.meetingId}?${fetch.makeUrlSearchParams({
-    occurrence_id: input.occurrence_id
-  })}`, {
-    method: 'PATCH',
-    body: JSON.stringify(input.template)
-  });
+    return (input) => context.fetchJson(`/meetings/${input.meetingId}?${fetch.makeUrlSearchParams({ occurrence_id: input.occurrence_id })}`, {
+        method: 'PATCH',
+        body: JSON.stringify(input.template)
+    });
 }
 const 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}?${fetch.makeUrlSearchParams(input, omitSilenceZoomErrorKeys())}`, 'DELETE').catch(silenceDoesNotExistError(input.silenceError));
+    const silenceDoesNotExistError = silenceZoomErrorWithCodesFunction(DELETE_MEETING_DOES_NOT_EXIST_ERROR_CODE);
+    return (input) => context.fetchJson(`/meetings/${input.meetingId}?${fetch.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');
+    return (input) => context.fetchJson(`/past_meetings/${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'));
+    return (input) => context.fetchJson(`/past_meetings/${input.meetingId}/participants`, 'GET').then(mapToZoomPageResult('participants'));
 }
 function getPastMeetingParticipantsPageFactory(context) {
-  return zoomFetchPageFactory(getPastMeetingParticipants(context));
+    return zoomFetchPageFactory(getPastMeetingParticipants(context));
 }
 
 /**
@@ -307,66 +279,66 @@ function getPastMeetingParticipantsPageFactory(context) {
  */
 exports.ZoomMeetingType = void 0;
 (function (ZoomMeetingType) {
-  ZoomMeetingType[ZoomMeetingType["INSTANT"] = 1] = "INSTANT";
-  ZoomMeetingType[ZoomMeetingType["SCHEDULED"] = 2] = "SCHEDULED";
-  ZoomMeetingType[ZoomMeetingType["RECURRING_NO_FIXED_TIME"] = 3] = "RECURRING_NO_FIXED_TIME";
-  ZoomMeetingType[ZoomMeetingType["PMI"] = 4] = "PMI";
-  ZoomMeetingType[ZoomMeetingType["RECURRING_FIXED_TIME"] = 8] = "RECURRING_FIXED_TIME";
-  ZoomMeetingType[ZoomMeetingType["SCREEN_SHARE_ONLY"] = 10] = "SCREEN_SHARE_ONLY";
+    ZoomMeetingType[ZoomMeetingType["INSTANT"] = 1] = "INSTANT";
+    ZoomMeetingType[ZoomMeetingType["SCHEDULED"] = 2] = "SCHEDULED";
+    ZoomMeetingType[ZoomMeetingType["RECURRING_NO_FIXED_TIME"] = 3] = "RECURRING_NO_FIXED_TIME";
+    ZoomMeetingType[ZoomMeetingType["PMI"] = 4] = "PMI";
+    ZoomMeetingType[ZoomMeetingType["RECURRING_FIXED_TIME"] = 8] = "RECURRING_FIXED_TIME";
+    ZoomMeetingType[ZoomMeetingType["SCREEN_SHARE_ONLY"] = 10] = "SCREEN_SHARE_ONLY";
 })(exports.ZoomMeetingType || (exports.ZoomMeetingType = {}));
 exports.ZoomRecurrenceType = void 0;
 (function (ZoomRecurrenceType) {
-  ZoomRecurrenceType[ZoomRecurrenceType["DAILY"] = 1] = "DAILY";
-  ZoomRecurrenceType[ZoomRecurrenceType["WEEKLY"] = 2] = "WEEKLY";
-  ZoomRecurrenceType[ZoomRecurrenceType["MONTHLY"] = 3] = "MONTHLY";
+    ZoomRecurrenceType[ZoomRecurrenceType["DAILY"] = 1] = "DAILY";
+    ZoomRecurrenceType[ZoomRecurrenceType["WEEKLY"] = 2] = "WEEKLY";
+    ZoomRecurrenceType[ZoomRecurrenceType["MONTHLY"] = 3] = "MONTHLY";
 })(exports.ZoomRecurrenceType || (exports.ZoomRecurrenceType = {}));
 exports.ZoomMonthlyWeek = void 0;
 (function (ZoomMonthlyWeek) {
-  ZoomMonthlyWeek[ZoomMonthlyWeek["LAST_WEEK"] = -1] = "LAST_WEEK";
-  ZoomMonthlyWeek[ZoomMonthlyWeek["FIRST_WEEK"] = 1] = "FIRST_WEEK";
-  ZoomMonthlyWeek[ZoomMonthlyWeek["SECOND_WEEK"] = 2] = "SECOND_WEEK";
-  ZoomMonthlyWeek[ZoomMonthlyWeek["THIRD_WEEK"] = 3] = "THIRD_WEEK";
-  ZoomMonthlyWeek[ZoomMonthlyWeek["FOURTH_WEEK"] = 4] = "FOURTH_WEEK";
+    ZoomMonthlyWeek[ZoomMonthlyWeek["LAST_WEEK"] = -1] = "LAST_WEEK";
+    ZoomMonthlyWeek[ZoomMonthlyWeek["FIRST_WEEK"] = 1] = "FIRST_WEEK";
+    ZoomMonthlyWeek[ZoomMonthlyWeek["SECOND_WEEK"] = 2] = "SECOND_WEEK";
+    ZoomMonthlyWeek[ZoomMonthlyWeek["THIRD_WEEK"] = 3] = "THIRD_WEEK";
+    ZoomMonthlyWeek[ZoomMonthlyWeek["FOURTH_WEEK"] = 4] = "FOURTH_WEEK";
 })(exports.ZoomMonthlyWeek || (exports.ZoomMonthlyWeek = {}));
 exports.ZoomMonthlyWeekDay = void 0;
 (function (ZoomMonthlyWeekDay) {
-  ZoomMonthlyWeekDay[ZoomMonthlyWeekDay["SUNDAY"] = 1] = "SUNDAY";
-  ZoomMonthlyWeekDay[ZoomMonthlyWeekDay["MONDAY"] = 2] = "MONDAY";
-  ZoomMonthlyWeekDay[ZoomMonthlyWeekDay["TUESDAY"] = 3] = "TUESDAY";
-  ZoomMonthlyWeekDay[ZoomMonthlyWeekDay["WEDNESDAY"] = 4] = "WEDNESDAY";
-  ZoomMonthlyWeekDay[ZoomMonthlyWeekDay["THURSDAY"] = 5] = "THURSDAY";
-  ZoomMonthlyWeekDay[ZoomMonthlyWeekDay["FRIDAY"] = 6] = "FRIDAY";
-  ZoomMonthlyWeekDay[ZoomMonthlyWeekDay["SATURDAY"] = 7] = "SATURDAY";
+    ZoomMonthlyWeekDay[ZoomMonthlyWeekDay["SUNDAY"] = 1] = "SUNDAY";
+    ZoomMonthlyWeekDay[ZoomMonthlyWeekDay["MONDAY"] = 2] = "MONDAY";
+    ZoomMonthlyWeekDay[ZoomMonthlyWeekDay["TUESDAY"] = 3] = "TUESDAY";
+    ZoomMonthlyWeekDay[ZoomMonthlyWeekDay["WEDNESDAY"] = 4] = "WEDNESDAY";
+    ZoomMonthlyWeekDay[ZoomMonthlyWeekDay["THURSDAY"] = 5] = "THURSDAY";
+    ZoomMonthlyWeekDay[ZoomMonthlyWeekDay["FRIDAY"] = 6] = "FRIDAY";
+    ZoomMonthlyWeekDay[ZoomMonthlyWeekDay["SATURDAY"] = 7] = "SATURDAY";
 })(exports.ZoomMonthlyWeekDay || (exports.ZoomMonthlyWeekDay = {}));
 exports.ZoomApprovalType = void 0;
 (function (ZoomApprovalType) {
-  /**
-   * Automatically approve.
-   */
-  ZoomApprovalType[ZoomApprovalType["AUTOMATICALLY_APPROVE"] = 0] = "AUTOMATICALLY_APPROVE";
-  /**
-   * Manually approve.
-   */
-  ZoomApprovalType[ZoomApprovalType["MANUALLY_APPROVE"] = 1] = "MANUALLY_APPROVE";
-  /**
-   * No registration required.
-   */
-  ZoomApprovalType[ZoomApprovalType["NO_REGISTRATION_REQUIRED"] = 2] = "NO_REGISTRATION_REQUIRED";
+    /**
+     * Automatically approve.
+     */
+    ZoomApprovalType[ZoomApprovalType["AUTOMATICALLY_APPROVE"] = 0] = "AUTOMATICALLY_APPROVE";
+    /**
+     * Manually approve.
+     */
+    ZoomApprovalType[ZoomApprovalType["MANUALLY_APPROVE"] = 1] = "MANUALLY_APPROVE";
+    /**
+     * No registration required.
+     */
+    ZoomApprovalType[ZoomApprovalType["NO_REGISTRATION_REQUIRED"] = 2] = "NO_REGISTRATION_REQUIRED";
 })(exports.ZoomApprovalType || (exports.ZoomApprovalType = {}));
 exports.ZoomRegistrationType = void 0;
 (function (ZoomRegistrationType) {
-  /**
-   * Attendees register once and can attend any meeting occurrence.
-   */
-  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";
-  /**
-   * Attendees register once and can select one or more meeting occurrences to attend.
-   */
-  ZoomRegistrationType[ZoomRegistrationType["REGISTER_ONCE_CHOOSE_OCCURRENCES"] = 3] = "REGISTER_ONCE_CHOOSE_OCCURRENCES";
+    /**
+     * Attendees register once and can attend any meeting occurrence.
+     */
+    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";
+    /**
+     * Attendees register once and can select one or more meeting occurrences to attend.
+     */
+    ZoomRegistrationType[ZoomRegistrationType["REGISTER_ONCE_CHOOSE_OCCURRENCES"] = 3] = "REGISTER_ONCE_CHOOSE_OCCURRENCES";
 })(exports.ZoomRegistrationType || (exports.ZoomRegistrationType = {}));
 
 /**
@@ -376,7 +348,7 @@ exports.ZoomRegistrationType = void 0;
  * @returns
  */
 function getUser(context) {
-  return input => context.fetchJson(`/users/${input.userId}`, 'GET');
+    return (input) => context.fetchJson(`/users/${input.userId}`, 'GET');
 }
 /**
  * https://developers.zoom.us/docs/api/users/#tag/users/GET/users
@@ -385,40 +357,40 @@ function getUser(context) {
  * @returns
  */
 function listUsers(context) {
-  return input => context.fetchJson(`/users?${fetch.makeUrlSearchParams(input)}`, 'GET').then(mapToZoomPageResult('users'));
+    return (input) => context.fetchJson(`/users?${fetch.makeUrlSearchParams(input)}`, 'GET').then(mapToZoomPageResult('users'));
 }
 function listUsersPageFactory(context) {
-  return zoomFetchPageFactory(listUsers(context));
+    return zoomFetchPageFactory(listUsers(context));
 }
 
 exports.ZoomUserType = void 0;
 (function (ZoomUserType) {
-  ZoomUserType[ZoomUserType["Basic"] = 1] = "Basic";
-  ZoomUserType[ZoomUserType["Licensed"] = 2] = "Licensed";
-  ZoomUserType[ZoomUserType["Unassigned"] = 4] = "Unassigned";
-  ZoomUserType[ZoomUserType["None"] = 99] = "None";
+    ZoomUserType[ZoomUserType["Basic"] = 1] = "Basic";
+    ZoomUserType[ZoomUserType["Licensed"] = 2] = "Licensed";
+    ZoomUserType[ZoomUserType["Unassigned"] = 4] = "Unassigned";
+    ZoomUserType[ZoomUserType["None"] = 99] = "None";
 })(exports.ZoomUserType || (exports.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);
-  }
-  return result;
+    const data = await responseError.response.json().catch((x) => undefined);
+    let result;
+    if (data) {
+        result = parseZoomApiServerErrorResponseData(data, responseError);
+    }
+    return result;
 }
 function parseZoomApiServerErrorResponseData(zoomServerError, responseError) {
-  let result;
-  if (zoomServerError) {
-    switch (zoomServerError.code) {
-      default:
-        result = parseZoomServerErrorData(zoomServerError, responseError);
-        break;
+    let result;
+    if (zoomServerError) {
+        switch (zoomServerError.code) {
+            default:
+                result = parseZoomServerErrorData(zoomServerError, responseError);
+                break;
+        }
     }
-  }
-  return result;
+    return result;
 }
 const handleZoomErrorFetch = handleZoomErrorFetchFactory(parseZoomApiError, logZoomErrorToConsole);
 
@@ -431,46 +403,46 @@ const 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 fetch.FetchRequestFactoryError {
-  constructor(errorCode) {
-    super(`ZoomOAuthAccessTokenError: ${errorCode}`);
-    this.errorCode = void 0;
-    this.errorCode = errorCode;
-  }
+    errorCode;
+    constructor(errorCode) {
+        super(`ZoomOAuthAccessTokenError: ${errorCode}`);
+        this.errorCode = errorCode;
+    }
 }
 /**
  * Thrown if a valid ZoomAccessToken cannot be retrieved successfully.
  */
 class ZoomOAuthAuthFailureError extends fetch.FetchRequestFactoryError {
-  constructor(reason) {
-    super(`Failed to retrieve proper authentication for the API call. Reason: ${reason}`);
-    this.reason = void 0;
-    this.reason = reason;
-  }
+    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);
-  }
-  return result;
+    const data = await responseError.response.json().catch((x) => undefined);
+    let result;
+    if (data) {
+        result = parseZoomOAuthServerErrorResponseData(data, responseError);
+    }
+    return result;
 }
 function parseZoomOAuthServerErrorResponseData(zoomServerError, responseError) {
-  let result;
-  if (zoomServerError) {
-    const potentialErrorStringCode = zoomServerError.error;
-    const errorCode = potentialErrorStringCode ?? zoomServerError.code;
-    switch (errorCode) {
-      case ZOOM_ACCOUNTS_INVALID_GRANT_ERROR_CODE:
-        result = new ZoomOAuthAccessTokenError(errorCode);
-        break;
-      default:
-        result = parseZoomServerErrorData(zoomServerError, responseError);
-        break;
+    let result;
+    if (zoomServerError) {
+        const potentialErrorStringCode = zoomServerError.error;
+        const errorCode = potentialErrorStringCode ?? zoomServerError.code;
+        switch (errorCode) {
+            case ZOOM_ACCOUNTS_INVALID_GRANT_ERROR_CODE:
+                result = new ZoomOAuthAccessTokenError(errorCode);
+                break;
+            default:
+                result = parseZoomServerErrorData(zoomServerError, responseError);
+                break;
+        }
     }
-  }
-  return result;
+    return result;
 }
 const handleZoomOAuthErrorFetch = handleZoomErrorFetchFactory(parseZoomOAuthError, logZoomOAuthErrorToConsole);
 
@@ -478,76 +450,72 @@ const handleZoomOAuthErrorFetch = handleZoomErrorFetchFactory(parseZoomOAuthErro
  * Generates a new ZoomAccessTokenStringFactory.
  */
 function zoomAccessTokenStringFactory(zoomAccessTokenFactory) {
-  return async () => {
-    const token = await zoomAccessTokenFactory();
-    if (!token?.accessToken) {
-      throw new ZoomOAuthAuthFailureError();
-    }
-    return token.accessToken;
-  };
+    return async () => {
+        const token = await zoomAccessTokenFactory();
+        if (!token?.accessToken) {
+            throw new ZoomOAuthAuthFailureError();
+        }
+        return 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}.`);
+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}.`);
 };
 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;
-  function configForLimit(limit, resetAt) {
-    return {
-      limit: defaultLimit,
-      startLimitAt: 2,
-      cooldownRate: 1,
-      exponentRate: 1.2,
-      maxWaitTime: util.MS_IN_SECOND * 5,
-      resetPeriod: defaultResetPeriod,
-      resetAt
-    };
-  }
-  const defaultConfig = configForLimit();
-  const rateLimiter = util.resetPeriodPromiseRateLimiter(defaultConfig);
-  return fetch.rateLimitedFetchHandler({
-    rateLimiter,
-    updateWithResponse: function (response, fetchResponseError) {
-      const hasLimitHeader = response.headers.has(ZOOM_RATE_LIMIT_REMAINING_HEADER);
-      let shouldRetry = false;
-      // let enabled = false;   // rate limiter should not be turned off
-      if (hasLimitHeader) {
-        const headerDetails = zoomRateLimitHeaderDetails(response.headers);
-        if (headerDetails) {
-          const {
-            type,
-            limit,
-            retryAfterAt,
-            remaining
-          } = headerDetails;
-          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) {}
-            }
-          }
-          // 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);
-              rateLimiter.setConfig(newConfig, false);
+    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;
+    function configForLimit(limit, resetAt) {
+        return {
+            limit: defaultLimit,
+            startLimitAt: 2,
+            cooldownRate: 1,
+            exponentRate: 1.2,
+            maxWaitTime: util.MS_IN_SECOND * 5,
+            resetPeriod: defaultResetPeriod,
+            resetAt
+        };
+    }
+    const defaultConfig = configForLimit();
+    const rateLimiter = util.resetPeriodPromiseRateLimiter(defaultConfig);
+    return fetch.rateLimitedFetchHandler({
+        rateLimiter,
+        updateWithResponse: function (response, fetchResponseError) {
+            const hasLimitHeader = response.headers.has(ZOOM_RATE_LIMIT_REMAINING_HEADER);
+            let shouldRetry = false;
+            // let enabled = false;   // rate limiter should not be turned off
+            if (hasLimitHeader) {
+                const headerDetails = zoomRateLimitHeaderDetails(response.headers);
+                if (headerDetails) {
+                    const { type, limit, retryAfterAt, remaining } = headerDetails;
+                    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) { }
+                        }
+                    }
+                    // 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);
+                            rateLimiter.setConfig(newConfig, false);
+                        }
+                        rateLimiter.setRemainingLimit(remaining);
+                        rateLimiter.setNextResetAt(retryAfterAt);
+                        // enabled = true;
+                    }
+                }
             }
-            rateLimiter.setRemainingLimit(remaining);
-            rateLimiter.setNextResetAt(retryAfterAt);
-            // enabled = true;
-          }
+            // rateLimiter.setEnabled(enabled);
+            return shouldRetry;
         }
-      }
-      // rateLimiter.setEnabled(enabled);
-      return shouldRetry;
-    }
-  });
+    });
 }
 
 /**
@@ -556,76 +524,69 @@ function zoomRateLimitedFetchHandler(config) {
 const 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 => fetch.fetchApiFetchService.makeFetch({
-      baseUrl: ZOOM_API_URL,
-      baseRequest: async () => ({
-        headers: {
-          'Content-Type': 'application/json',
-          Authorization: `Bearer ${await input.zoomAccessTokenStringFactory()}`
-        }
-      }),
-      fetchHandler,
-      timeout: 20 * 1000,
-      // 20 second timeout
-      requireOkResponse: true,
-      // enforce ok response
-      useTimeout: true // use timeout
-    })
-  } = factoryConfig;
-  return config => {
-    const baseFetch = fetchFactory({
-      zoomAccessTokenStringFactory: serverAccessTokenStringFactory
-    });
-    const serverFetch = handleZoomErrorFetch(baseFetch, logZoomServerErrorFunction);
-    const serverFetchJson = fetch.fetchJsonFunction(serverFetch, {
-      handleFetchJsonParseErrorFunction: fetch.returnNullHandleFetchJsonParseErrorFunction
-    });
-    // MARK: Make User Context
-    const makeUserContext = input => {
-      const userAccessTokenFactory = oauthContext.makeUserAccessTokenFactory({
-        refreshToken: input.refreshToken,
-        userAccessTokenCache: input.accessTokenCache
-      });
-      const userAccessTokenStringFactory = zoomAccessTokenStringFactory(userAccessTokenFactory);
-      const userFetch = fetchFactory({
-        zoomAccessTokenStringFactory: userAccessTokenStringFactory
-      });
-      const userFetchJson = fetch.fetchJsonFunction(userFetch, {
-        handleFetchJsonParseErrorFunction: fetch.returnNullHandleFetchJsonParseErrorFunction
-      });
-      const result = {
-        zoomServerContext: zoomContext,
-        type: 'user',
-        fetch: userFetch,
-        fetchJson: userFetchJson,
-        userFetch,
-        userFetchJson,
-        zoomRateLimiter: fetchHandler._rateLimiter
-      };
-      return result;
-    };
-    const zoomContext = {
-      type: 'server',
-      fetch: serverFetch,
-      fetchJson: serverFetchJson,
-      serverFetch,
-      serverFetchJson,
-      makeUserContext,
-      config,
-      zoomRateLimiter: fetchHandler._rateLimiter
-    };
-    const zoom = {
-      zoomServerContext: zoomContext
+    const { oauthContext } = factoryConfig;
+    const serverAccessTokenStringFactory = zoomAccessTokenStringFactory(oauthContext.loadAccessToken);
+    const fetchHandler = zoomRateLimitedFetchHandler(factoryConfig.rateLimiterConfig);
+    const { logZoomServerErrorFunction, fetchFactory = (input) => fetch.fetchApiFetchService.makeFetch({
+        baseUrl: ZOOM_API_URL,
+        baseRequest: async () => ({
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${await input.zoomAccessTokenStringFactory()}`
+            }
+        }),
+        fetchHandler,
+        timeout: 20 * 1000, // 20 second timeout
+        requireOkResponse: true, // enforce ok response
+        useTimeout: true // use timeout
+    }) } = factoryConfig;
+    return (config) => {
+        const baseFetch = fetchFactory({
+            zoomAccessTokenStringFactory: serverAccessTokenStringFactory
+        });
+        const serverFetch = handleZoomErrorFetch(baseFetch, logZoomServerErrorFunction);
+        const serverFetchJson = fetch.fetchJsonFunction(serverFetch, {
+            handleFetchJsonParseErrorFunction: fetch.returnNullHandleFetchJsonParseErrorFunction
+        });
+        // MARK: Make User Context
+        const makeUserContext = (input) => {
+            const userAccessTokenFactory = oauthContext.makeUserAccessTokenFactory({
+                refreshToken: input.refreshToken,
+                userAccessTokenCache: input.accessTokenCache
+            });
+            const userAccessTokenStringFactory = zoomAccessTokenStringFactory(userAccessTokenFactory);
+            const userFetch = fetchFactory({
+                zoomAccessTokenStringFactory: userAccessTokenStringFactory
+            });
+            const userFetchJson = fetch.fetchJsonFunction(userFetch, {
+                handleFetchJsonParseErrorFunction: fetch.returnNullHandleFetchJsonParseErrorFunction
+            });
+            const result = {
+                zoomServerContext: zoomContext,
+                type: 'user',
+                fetch: userFetch,
+                fetchJson: userFetchJson,
+                userFetch,
+                userFetchJson,
+                zoomRateLimiter: fetchHandler._rateLimiter
+            };
+            return result;
+        };
+        const zoomContext = {
+            type: 'server',
+            fetch: serverFetch,
+            fetchJson: serverFetchJson,
+            serverFetch,
+            serverFetchJson,
+            makeUserContext,
+            config,
+            zoomRateLimiter: fetchHandler._rateLimiter
+        };
+        const zoom = {
+            zoomServerContext: zoomContext
+        };
+        return zoom;
     };
-    return zoom;
-  };
 }
 
 /**
@@ -635,9 +596,9 @@ function zoomFactory(factoryConfig) {
  * @returns
  */
 function serverAccessToken(context) {
-  return input => {
-    return context.fetchJson(`/token?grant_type=account_credentials&account_id=${input?.accountId ?? context.config.accountId}`, zoomOAuthApiFetchJsonInput(context, input));
-  };
+    return (input) => {
+        return context.fetchJson(`/token?grant_type=account_credentials&account_id=${input?.accountId ?? context.config.accountId}`, zoomOAuthApiFetchJsonInput(context, input));
+    };
 }
 /**
  * Retrieves a new AccessToken for a user using their refresh token.
@@ -646,27 +607,27 @@ function serverAccessToken(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));
-  };
+    return (input) => {
+        const refreshToken = input.refreshToken;
+        return context.fetchJson(`/token?grant_type=refresh_token&refresh_token=${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 = {
-    headers: {
-      Authorization: zoomOAuthServerBasicAuthorizationHeaderValue({
-        clientId,
-        clientSecret
-      })
-    },
-    method: 'POST'
-  };
-  return fetchJsonInput;
+    const clientId = input?.client?.clientId ?? context.config.clientId;
+    const clientSecret = input?.client?.clientSecret ?? context.config.clientSecret;
+    const fetchJsonInput = {
+        headers: {
+            Authorization: zoomOAuthServerBasicAuthorizationHeaderValue({
+                clientId,
+                clientSecret
+            })
+        },
+        method: 'POST'
+    };
+    return fetchJsonInput;
 }
 function zoomOAuthServerBasicAuthorizationHeaderValue(input) {
-  return `Basic ${Buffer.from(`${input.clientId}:${input.clientSecret}`).toString('base64')}`;
+    return `Basic ${Buffer.from(`${input.clientId}:${input.clientSecret}`).toString('base64')}`;
 }
 
 /**
@@ -675,85 +636,77 @@ function zoomOAuthServerBasicAuthorizationHeaderValue(input) {
 const ZOOM_OAUTH_API_URL = 'https://zoom.us/oauth';
 
 function zoomOAuthFactory(factoryConfig) {
-  const fetchHandler = zoomRateLimitedFetchHandler();
-  const {
-    logZoomServerErrorFunction,
-    fetchFactory = _ => fetch.fetchApiFetchService.makeFetch({
-      baseUrl: ZOOM_OAUTH_API_URL,
-      baseRequest: {
-        headers: {
-          'Content-Type': 'application/json'
+    const fetchHandler = zoomRateLimitedFetchHandler();
+    const { logZoomServerErrorFunction, fetchFactory = (_) => fetch.fetchApiFetchService.makeFetch({
+        baseUrl: ZOOM_OAUTH_API_URL,
+        baseRequest: {
+            headers: {
+                'Content-Type': 'application/json'
+            }
+        },
+        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.');
         }
-      },
-      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.');
-    } else if (!config.accountId) {
-      throw new Error('ZoomOAuthConfig missing accountId.');
-    }
-    const baseFetch = fetchFactory();
-    const fetch$1 = handleZoomOAuthErrorFetch(baseFetch, logZoomServerErrorFunction);
-    const fetchJson = fetch.fetchJsonFunction(fetch$1, {
-      handleFetchJsonParseErrorFunction: fetch.returnNullHandleFetchJsonParseErrorFunction
-    });
-    function accessTokenFromTokenResponse(result) {
-      const createdAt = new Date().getTime();
-      const {
-        access_token,
-        api_url,
-        scope,
-        expires_in
-      } = result;
-      const accessToken = {
-        accessToken: access_token,
-        apiDomain: api_url,
-        expiresIn: expires_in,
-        expiresAt: new Date(createdAt + expires_in * util.MS_IN_SECOND),
-        scope
-      };
-      return accessToken;
-    }
-    const tokenRefresher = async () => {
-      const accessToken = await serverAccessToken(oauthContext)();
-      return accessTokenFromTokenResponse(accessToken);
-    };
-    const loadAccessToken = zoomOAuthZoomAccessTokenFactory({
-      tokenRefresher,
-      accessTokenCache: config.accessTokenCache
-    });
-    // User Access Token
-    const makeUserAccessTokenFactory = input => {
-      const userTokenRefresher = async () => {
-        const accessToken = await userAccessToken(oauthContext)(input);
-        return accessTokenFromTokenResponse(accessToken);
-      };
-      return zoomOAuthZoomAccessTokenFactory({
-        tokenRefresher: userTokenRefresher,
-        accessTokenCache: input.userAccessTokenCache
-      });
-    };
-    const oauthContext = {
-      fetch: fetch$1,
-      fetchJson,
-      loadAccessToken,
-      makeUserAccessTokenFactory,
-      config
-    };
-    const zoomOAuth = {
-      oauthContext
+        else if (!config.clientSecret) {
+            throw new Error('ZoomOAuthConfig missing clientSecret.');
+        }
+        else if (!config.accountId) {
+            throw new Error('ZoomOAuthConfig missing accountId.');
+        }
+        const baseFetch = fetchFactory();
+        const fetch$1 = handleZoomOAuthErrorFetch(baseFetch, logZoomServerErrorFunction);
+        const fetchJson = fetch.fetchJsonFunction(fetch$1, {
+            handleFetchJsonParseErrorFunction: fetch.returnNullHandleFetchJsonParseErrorFunction
+        });
+        function accessTokenFromTokenResponse(result) {
+            const createdAt = new Date().getTime();
+            const { access_token, api_url, scope, expires_in } = result;
+            const accessToken = {
+                accessToken: access_token,
+                apiDomain: api_url,
+                expiresIn: expires_in,
+                expiresAt: new Date(createdAt + expires_in * util.MS_IN_SECOND),
+                scope
+            };
+            return accessToken;
+        }
+        const tokenRefresher = async () => {
+            const accessToken = await serverAccessToken(oauthContext)();
+            return accessTokenFromTokenResponse(accessToken);
+        };
+        const loadAccessToken = zoomOAuthZoomAccessTokenFactory({
+            tokenRefresher,
+            accessTokenCache: config.accessTokenCache
+        });
+        // User Access Token
+        const makeUserAccessTokenFactory = (input) => {
+            const userTokenRefresher = async () => {
+                const accessToken = await userAccessToken(oauthContext)(input);
+                return accessTokenFromTokenResponse(accessToken);
+            };
+            return zoomOAuthZoomAccessTokenFactory({
+                tokenRefresher: userTokenRefresher,
+                accessTokenCache: input.userAccessTokenCache
+            });
+        };
+        const oauthContext = {
+            fetch: fetch$1,
+            fetchJson,
+            loadAccessToken,
+            makeUserAccessTokenFactory,
+            config
+        };
+        const zoomOAuth = {
+            oauthContext
+        };
+        return zoomOAuth;
     };
-    return zoomOAuth;
-  };
 }
 /**
  * Creates a ZoomOAuthZoomAccessTokenFactoryConfig
@@ -762,49 +715,47 @@ function zoomOAuthFactory(factoryConfig) {
  * @returns
  */
 function zoomOAuthZoomAccessTokenFactory(config) {
-  const {
-    tokenRefresher,
-    accessTokenCache,
-    tokenExpirationBuffer: inputTokenExpirationBuffer
-  } = config;
-  const tokenExpirationBuffer = inputTokenExpirationBuffer ?? util.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
+    const { tokenRefresher, accessTokenCache, tokenExpirationBuffer: inputTokenExpirationBuffer } = config;
+    const tokenExpirationBuffer = inputTokenExpirationBuffer ?? util.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;
+            }
         }
-      }
-    }
-    return currentToken;
-  };
+        // 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
+                }
+            }
+        }
+        return currentToken;
+    };
 }
 
 exports.DEFAULT_ZOOM_API_RATE_LIMIT = DEFAULT_ZOOM_API_RATE_LIMIT;