@dereekb/zoom 12.1.0

package/src/lib/zoom/zoom.api.user.type.d.ts

@@ -0,0 +1,287 @@
+import { EmailAddress, ISO8601DateStringUTCFull, TimezoneString } from '@dereekb/util';
+import { ZoomClientVersion, ZoomUserId } from '../zoom.type';
+/**
+ * Represents a Zoom user, as returned by the Zoom API.
+ */
+export interface ZoomUser {
+    /**
+     * The user's ID. Not returned for users with 'pending' status.
+     *
+     * @example "KDcuGIm1QgePTO8WbOqwIQ"
+     */
+    readonly id: ZoomUserId;
+    /**
+     * The date and time when this user's latest login type was created.
+     *
+     * @example "2018-10-31T04:32:37Z"
+     */
+    readonly created_at: ISO8601DateStringUTCFull;
+    /**
+     * The date and time when this user was created.
+     *
+     * @example "2019-06-01T07:58:03Z"
+     */
+    readonly user_created_at: ISO8601DateStringUTCFull;
+    /**
+     * The user's department.
+     *
+     * @example "Developers"
+     */
+    readonly dept?: string;
+    /**
+     * The user's first name.
+     *
+     * @example "Jill"
+     */
+    readonly first_name: string;
+    /**
+     * The user's last name.
+     *
+     * @example "Chill"
+     */
+    readonly last_name: string;
+    /**
+     * The user's email address.
+     *
+     * @example "jchill@example.com"
+     */
+    readonly email: EmailAddress;
+    /**
+     * The employee's unique ID. Only returned when SAML SSO is enabled and login_type is 101 (SSO).
+     *
+     * @example "HqDyI037Qjili1kNsSIrIg"
+     */
+    readonly employee_unique_id?: string;
+    /**
+     * The IDs of groups where the user is a member.
+     */
+    readonly group_ids: string[];
+    /**
+     * The user's host key. Only returned if assigned and requested via include_fields.
+     */
+    readonly host_key?: string;
+    /**
+     * The IDs of IM directory groups where the user is a member.
+     */
+    readonly im_group_ids: string[];
+    /**
+     * The last client version that user used to log in.
+     *
+     * @example "5.2.45120.0906(win)"
+     */
+    readonly last_client_version: ZoomClientVersion;
+    /**
+     * The user's last login time. Has a three-day buffer period.
+     *
+     * @example "2022-03-25T05:40:55Z"
+     */
+    readonly last_login_time: ISO8601DateStringUTCFull;
+    /**
+     * Returned if the user is enrolled in the Zoom United plan. See docs for enum values.
+     * @example "1"
+     */
+    readonly plan_united_type?: ZoomUserPlanUnitedType;
+    /**
+     * The user's personal meeting ID (PMI).
+     * @example 6589310093
+     */
+    readonly pmi: ZoomUserPersonalMeetingId;
+    /**
+     * The unique ID of the user's assigned role.
+     * @example "0"
+     */
+    readonly role_id: ZoomUserRoleId;
+    /**
+     * The user's status: 'active', 'inactive', or 'pending'.
+     * @example "active"
+     */
+    readonly status: ZoomUserStatus;
+    /**
+     * The user's timezone.
+     * @example "Asia/Shanghai"
+     */
+    readonly timezone: TimezoneString;
+    /**
+     * The user's assigned plan type. 1 - Basic, 2 - Licensed, 4 - Unassigned, 99 - None (ssoCreate only).
+     *
+     * @example 1
+     */
+    readonly type: ZoomUserType;
+    /**
+     * Whether the user's email address is verified.
+     */
+    readonly verified: ZoomUserVerified;
+    /**
+     * The information about the user's custom attributes.
+     * This field is only returned if users are assigned custom attributes and you provided the `custom_attributes` value for the `include_fields` query parameter in the API request.
+     */
+    readonly custom_attributes?: ZoomUserCustomAttribute[];
+    /**
+     * The user's display name.
+     */
+    readonly display_name: string;
+    /**
+     * The user's role name (e.g., 'Owner').
+     */
+    readonly role_name: string;
+    /**
+     * Whether to use PMI for instant meetings.
+     */
+    readonly use_pmi: boolean;
+    /**
+     * The user's personal meeting URL.
+     */
+    readonly personal_meeting_url: string;
+    /**
+     * The user's profile picture URL.
+     */
+    readonly pic_url: string;
+    /**
+     * The user's CMS user ID (may be empty).
+     */
+    readonly cms_user_id?: string;
+    /**
+     * The user's XMPP JID (may be empty).
+     */
+    readonly jid?: string;
+    /**
+     * The user's account ID.
+     */
+    readonly account_id: string;
+    /**
+     * The user's language (e.g., 'en-US').
+     */
+    readonly language: string;
+    /**
+     * The user's phone country code (may be empty).
+     */
+    readonly phone_country?: string;
+    /**
+     * The user's phone number (may be empty).
+     */
+    readonly phone_number?: string;
+    /**
+     * The user's job title (may be empty).
+     */
+    readonly job_title?: string;
+    /**
+     * The user's cost center (may be empty).
+     */
+    readonly cost_center?: string;
+    /**
+     * The user's location (may be empty).
+     */
+    readonly location?: string;
+    /**
+     * The user's login types (array of numbers).
+     */
+    readonly login_types: number[];
+    /**
+     * The user's cluster (e.g., 'us05').
+     */
+    readonly cluster: string;
+    /**
+     * The user's manager (email address).
+     */
+    readonly manager?: string;
+    /**
+     * The user's phone numbers (new format, array of objects).
+     */
+    readonly phone_numbers?: ZoomUserPhoneNumber[];
+    /**
+     * The user's pronouns.
+     */
+    readonly pronouns?: string;
+    /**
+     * The user's display pronouns setting.
+     */
+    readonly pronouns_option?: number;
+    /**
+     * The user's vanity URL (personal meeting room URL).
+     */
+    readonly vanity_url?: string;
+    /**
+     * The user's account number.
+     */
+    readonly account_number?: number;
+    /**
+     * The user's company.
+     */
+    readonly company?: string;
+    /**
+     * The user's Zoom Workplace/Zoom One plan option.
+     */
+    readonly zoom_one_type?: number;
+}
+/**
+ * Represents a user's phone number object in the new phone_numbers format.
+ */
+export interface ZoomUserPhoneNumber {
+    /**
+     * The phone number's ISO country code.
+     *
+     * @example "US"
+     */
+    readonly code: string;
+    /**
+     * The phone number's country ID (e.g., 'US').
+     *
+     * @example "US"
+     */
+    readonly country: string;
+    /**
+     * The phone number's label (Mobile, Office, Home, Fax).
+     *
+     * @example "Mobile"
+     */
+    readonly label: 'Mobile' | 'Office' | 'Home' | 'Fax' | string;
+    /**
+     * The user's phone number.
+     *
+     * @example "5550100"
+     */
+    readonly number: string;
+    /**
+     * Whether Zoom has verified the phone number.
+     *
+     * @example true
+     */
+    readonly verified: boolean;
+}
+export type ZoomUserPersonalMeetingId = number;
+export type ZoomUserRoleId = string;
+export type ZoomUserStatus = 'active' | 'inactive' | 'pending';
+export declare enum ZoomUserType {
+    Basic = 1,
+    Licensed = 2,
+    Unassigned = 4,
+    None = 99
+}
+/**
+ * Whether the user's email address is verified.
+ *
+ * 1 - verified, 0 - not verified.
+ */
+export type ZoomUserVerified = 1 | 0;
+/**
+ * Custom attribute for a Zoom user.
+ */
+export interface ZoomUserCustomAttribute {
+    /**
+     * The custom attribute's unique ID.
+     */
+    readonly key: string;
+    /**
+     * The custom attribute's name.
+     */
+    readonly name: string;
+    /**
+     * The custom attribute's value.
+     */
+    readonly value: string;
+}
+/**
+ * Enum for plan_united_type field.
+ * See Zoom API documentation for details.
+ */
+export type ZoomUserPlanUnitedType = '1' | '2' | '4' | '8' | '16' | '32' | '64' | '128' | '256' | '512' | '1024' | '2048' | '4096' | '8192' | '16384' | '32768' | '65536' | '131072';

package/src/lib/zoom/zoom.config.d.ts

@@ -0,0 +1,69 @@
+import { FactoryWithInput, FactoryWithRequiredInput, Maybe } from '@dereekb/util';
+import { ConfiguredFetch, FetchJsonFunction } from '@dereekb/util/fetch';
+import { ZoomConfig, ZoomRefreshToken } from '../zoom.config';
+import { ZoomRateLimiterRef } from '../zoom.limit';
+import { ZoomAccessTokenCache, ZoomAccessTokenStringFactory } from '../oauth/oauth';
+export type ZoomApiKey = ZoomRefreshToken;
+export interface ZoomFetchFactoryInput {
+    readonly zoomAccessTokenStringFactory: ZoomAccessTokenStringFactory;
+}
+export type ZoomFetchFactory = FactoryWithInput<ConfiguredFetch, ZoomFetchFactoryInput>;
+/**
+ * Denotes the type of authorization used by the ZoomContext.
+ *
+ * - 'server': Uses Server to Server authorization
+ * - 'user': Uses User to Server authorization
+ */
+export type ZoomContextType = 'server' | 'user';
+/**
+ * A zoom context that can send requests to the Zoom API.
+ */
+export interface ZoomContext extends ZoomRateLimiterRef {
+    /**
+     * Type of context this is.
+     */
+    readonly type: ZoomContextType;
+    /**
+     * Performs a fetch as the server.
+     */
+    readonly fetch: ConfiguredFetch;
+    /**
+     * Performs a json fetch as the server.
+     */
+    readonly fetchJson: FetchJsonFunction;
+}
+export interface ZoomServerContext extends ZoomContext {
+    readonly type: 'server';
+    readonly serverFetch: ConfiguredFetch;
+    readonly serverFetchJson: FetchJsonFunction;
+    readonly makeUserContext: ZoomUserContextFactory;
+    readonly config: ZoomConfig;
+}
+export interface ZoomUserContextFactoryInput {
+    /**
+     * The user's refresh token.
+     */
+    readonly refreshToken: ZoomRefreshToken;
+    /**
+     * Optional cache to use for the user's access token.
+     *
+     * The cache should only be configured for the user that owns the refresh token.
+     */
+    readonly accessTokenCache?: Maybe<ZoomAccessTokenCache>;
+}
+/**
+ * Creates a ZoomUserContext from the input.
+ */
+export type ZoomUserContextFactory = FactoryWithRequiredInput<ZoomUserContext, ZoomUserContextFactoryInput>;
+/**
+ * Context used for performing fetch requests for a specific user.
+ */
+export interface ZoomUserContext extends ZoomContext {
+    readonly type: 'user';
+    readonly zoomServerContext: ZoomServerContext;
+    readonly userFetch: ConfiguredFetch;
+    readonly userFetchJson: FetchJsonFunction;
+}
+export interface ZoomServerContextRef {
+    readonly zoomServerContext: ZoomServerContext;
+}

package/src/lib/zoom/zoom.error.api.d.ts

@@ -0,0 +1,6 @@
+import { FetchResponseError } from '@dereekb/util/fetch';
+import { ZoomServerErrorData, ParsedZoomServerError } from '../zoom.error.api';
+export declare const logZoomErrorToConsole: import("../zoom.error.api").LogZoomServerErrorFunction;
+export declare function parseZoomApiError(responseError: FetchResponseError): Promise<ParsedZoomServerError>;
+export declare function parseZoomApiServerErrorResponseData(zoomServerError: ZoomServerErrorData, responseError: FetchResponseError): ParsedZoomServerError;
+export declare const handleZoomErrorFetch: import("../zoom.error.api").HandleZoomErrorFetchFactory;

package/src/lib/zoom/zoom.factory.d.ts

@@ -0,0 +1,23 @@
+import { ZoomServerContextRef, ZoomFetchFactory } from './zoom.config';
+import { LogZoomServerErrorFunction } from '../zoom.error.api';
+import { ZoomOAuthContextRef } from '../oauth/oauth.config';
+import { ZoomRateLimitedFetchHandlerConfig } from '../zoom.limit';
+import { type Maybe } from '@dereekb/util';
+import { ZoomConfig } from '../zoom.config';
+export type Zoom = ZoomServerContextRef;
+export interface ZoomFactoryConfig extends ZoomOAuthContextRef {
+    /**
+     * Custom ZoomRateLimitedFetchHandlerConfig
+     */
+    readonly rateLimiterConfig?: Maybe<ZoomRateLimitedFetchHandlerConfig>;
+    /**
+     * Creates a new fetch instance to use when making calls.
+     */
+    readonly fetchFactory?: ZoomFetchFactory;
+    /**
+     * Custom log error function.
+     */
+    readonly logZoomServerErrorFunction?: LogZoomServerErrorFunction;
+}
+export type ZoomFactory = (config: ZoomConfig) => Zoom;
+export declare function zoomFactory(factoryConfig: ZoomFactoryConfig): ZoomFactory;

package/src/lib/zoom.api.page.d.ts

@@ -0,0 +1,73 @@
+import { Maybe, PageNumber } from '@dereekb/util';
+import { FetchPageFactoryConfigDefaults } from '@dereekb/util/fetch';
+/**
+ * Base page filter
+ */
+export interface ZoomPageFilter {
+    readonly page_number?: number;
+    readonly page_size?: number;
+    readonly next_page_token?: string;
+}
+export type MapToZoomPageResultFunction<T> = (data: any) => ZoomPageResult<T>;
+/**
+ * The Zoom API returns the data for a page for a specific key.
+ *
+ * This function maps the data under that key to a ZoomPageResult with the data on the "data" variable.
+ 
+ * @param dataTypeKey
+ * @returns
+ */
+export declare function mapToZoomPageResult<T>(dataTypeKey: string): MapToZoomPageResultFunction<T>;
+export interface ZoomDataArrayResultRef<T> {
+    /**
+     * Array of data returned.
+     */
+    readonly data: T[];
+}
+/**
+ * Page result that contains an array of data and page information.
+ */
+export interface ZoomPageResult<T> extends ZoomDataArrayResultRef<T>, ZoomPageResultInfo {
+}
+/**
+ * Cursor for pagination.
+ */
+export type ZoomPageResultToken = string;
+/**
+ * Page information within a ZoomPageResult
+ */
+export interface ZoomPageResultInfo {
+    /**
+     * Use the next page token to paginate through large result sets. A next page token will be returned whenever the set of available results exceeds the current page size. This token's expiration period is 15 minutes.
+     */
+    readonly next_page_token: ZoomPageResultToken;
+    /**
+     * The number of pages returned for the request made.
+     *
+     * Possibly undefined for some calls.
+     */
+    readonly page_count?: number | undefined;
+    /**
+     * The page number of the current results.
+     *
+     * Possibly undefined for some calls.
+     */
+    readonly page_number?: PageNumber | undefined;
+    /**
+     * The number of records returned with a single API call.
+     */
+    readonly page_size: number;
+    /**
+     * The total number of all the records available across pages.
+     */
+    readonly total_records: number;
+}
+export type ZoomFetchPageFetchFunction<I extends ZoomPageFilter, R extends ZoomPageResult<any>> = (input: I) => Promise<R>;
+/**
+ * Creates a FetchPageFactory using the input ZoomFetchPageFetchFunction.
+ *
+ * @param fetch
+ * @param defaults
+ * @returns
+ */
+export declare function zoomFetchPageFactory<I extends ZoomPageFilter, R extends ZoomPageResult<any>>(fetch: ZoomFetchPageFetchFunction<I, R>, defaults?: Maybe<FetchPageFactoryConfigDefaults>): import("@dereekb/util/fetch").FetchPageFactory<I, R>;

package/src/lib/zoom.config.d.ts

@@ -0,0 +1,39 @@
+/**
+ * The Zoom API URL for the US datacenter.
+ */
+export declare const ZOOM_API_URL = "https://api.zoom.us/v2";
+/**
+ * Url for the Zoom API.
+ */
+export type ZoomApiUrl = typeof ZOOM_API_URL;
+/**
+ * Zoom Server Account ID used to identify a specific Zoom account.
+ *
+ * Can be found on the Server to Server app build page.
+ */
+export type ZoomAccountId = string;
+/**
+ * Non-expiring refresh token used to retrieve access tokens for performing API calls.
+ *
+ * https://www.zoom.com/recruit/developer-guide/apiv2/oauth-overview.html
+ *
+ * Is in the format of "1000.abc.123"
+ */
+export type ZoomRefreshToken = string;
+/**
+ * OAuth Client Id
+ */
+export type ZoomOAuthClientId = string;
+/**
+ * OAuth Client Secret
+ */
+export type ZoomOAuthClientSecret = string;
+export interface ZoomAccountIdRef {
+    readonly accountId: ZoomAccountId;
+}
+export interface ZoomAuthClientIdAndSecretPair {
+    readonly clientId: ZoomOAuthClientId;
+    readonly clientSecret: ZoomOAuthClientSecret;
+}
+export interface ZoomConfig {
+}

package/src/lib/zoom.error.api.d.ts

@@ -0,0 +1,145 @@
+import { ArrayOrValue, Maybe, UnixDateTimeNumber } from '@dereekb/util';
+import { ConfiguredFetch, FetchRequestFactoryError, FetchResponseError, MakeUrlSearchParamsOptions } from '@dereekb/util/fetch';
+import { BaseError } from 'make-error';
+/**
+ * A code used in some cases to denote success.
+ */
+export declare const ZOOM_SUCCESS_CODE = "SUCCESS";
+export type ZoomServerSuccessCode = typeof ZOOM_SUCCESS_CODE;
+export type ZoomServerSuccessStatus = 'success';
+export type ZoomServerErrorStatus = 'error';
+/**
+ * Zoom server error codes are numbers or strings.
+ *
+ * Check the API docs for specific functions to see what codes are used for what error.
+ */
+export type ZoomServerErrorCode = string | number;
+/**
+ * Zoom Server Error Data
+ *
+ * Always contains a code and message. Details and status are optional.
+ */
+export interface ZoomServerErrorData<T = unknown> {
+    readonly code: ZoomServerErrorCode;
+    readonly message: string;
+    readonly errors?: T;
+    /**
+     * Is sometimes present on some error responses.
+     */
+    readonly status?: ZoomServerErrorStatus;
+}
+/**
+ * Contains details and a status
+ */
+export type ZoomServerErrorDataWithDetails<T = unknown> = Required<ZoomServerErrorData<T>>;
+/**
+ * Zoom Server Error
+ */
+export declare class ZoomServerError<D extends ZoomServerErrorData = ZoomServerErrorData> extends BaseError {
+    readonly error: D;
+    get code(): ZoomServerErrorCode;
+    constructor(error: D);
+}
+/**
+ * Zoom Server Error that includes the FetchResponseError
+ */
+export declare class ZoomServerFetchResponseError<D extends ZoomServerErrorData = ZoomServerErrorData> extends ZoomServerError<D> {
+    readonly data: D;
+    readonly responseError: FetchResponseError;
+    constructor(data: D, responseError: FetchResponseError);
+}
+export type LogZoomServerErrorFunction = (error: FetchRequestFactoryError | ZoomServerError | ZoomServerFetchResponseError) => void;
+/**
+ * Creates a logZoomServerErrorFunction that logs the error to console.
+ *
+ * @param zoomApiNamePrefix Prefix to use when logging. I.E. ZoomError, etc.
+ * @returns
+ */
+export declare function logZoomServerErrorFunction(zoomApiNamePrefix: string): LogZoomServerErrorFunction;
+/**
+ * Wraps a ConfiguredFetch to support handling errors returned by fetch.
+ *
+ * @param fetch
+ * @returns
+ */
+export type HandleZoomErrorFetchFactory = (fetch: ConfiguredFetch, logError?: LogZoomServerErrorFunction) => ConfiguredFetch;
+export type ParsedZoomServerError = FetchRequestFactoryError | ZoomServerError | undefined;
+export type ParseZoomFetchResponseErrorFunction = (responseError: FetchResponseError) => Promise<ParsedZoomServerError>;
+/**
+ * Wraps a ConfiguredFetch to support handling errors returned by fetch.
+ *
+ * @param fetch
+ * @returns
+ */
+export declare function handleZoomErrorFetchFactory(parseZoomError: ParseZoomFetchResponseErrorFunction, defaultLogError: LogZoomServerErrorFunction): HandleZoomErrorFetchFactory;
+/**
+ * The status code that Zoom uses to indicates that too many requests have been made in a short period of time.
+ */
+export declare const ZOOM_TOO_MANY_REQUESTS_HTTP_STATUS_CODE = 429;
+export type ZoomRateLimitCategory = 'Light' | 'Medium' | 'Heavy';
+export type ZoomRateLimitType = 'Per-second-limit' | 'Daily-limit';
+export declare const ZOOM_RATE_LIMIT_CATEGORY_HEADER = "X-RateLimit-Category";
+export declare const ZOOM_RATE_LIMIT_TYPE_HEADER = "X-RateLimit-Type";
+export declare const ZOOM_RATE_LIMIT_LIMIT_HEADER = "X-RateLimit-Limit";
+export declare const ZOOM_RATE_LIMIT_REMAINING_HEADER = "X-RateLimit-Remaining";
+export declare const ZOOM_RATE_LIMIT_RETRY_AFTER_HEADER = "Retry-After";
+export declare const DEFAULT_ZOOM_API_RATE_LIMIT = 100;
+export declare const DEFAULT_ZOOM_API_RATE_LIMIT_RESET_PERIOD: number;
+export interface ZoomRateLimitHeaderDetails {
+    /**
+     * Total limit in a given period.
+     */
+    readonly limit: number;
+    /**
+     * Total number of remaining allowed requests.
+     */
+    readonly remaining: number;
+    /**
+     * The category of the rate limit.
+     */
+    readonly category: ZoomRateLimitCategory;
+    /**
+     * The type of the rate limit.
+     */
+    readonly type: ZoomRateLimitType;
+    /**
+     * The time at which the rate limit will reset.
+     */
+    readonly retryAfter: UnixDateTimeNumber;
+    /**
+     * The time at which the rate limit will reset.
+     */
+    readonly retryAfterAt: Date;
+}
+export declare function zoomRateLimitHeaderDetails(headers: Headers): Maybe<ZoomRateLimitHeaderDetails>;
+export declare class ZoomTooManyRequestsError extends ZoomServerFetchResponseError {
+    get headerDetails(): Maybe<ZoomRateLimitHeaderDetails>;
+}
+/**
+ * Function that parses/transforms a ZoomServerErrorData into a general ZoomServerError or other known error type.
+ *
+ * @param errorResponseData
+ * @param responseError
+ * @returns
+ */
+export declare function parseZoomServerErrorData(zoomServerError: ZoomServerErrorData, responseError: FetchResponseError): ZoomServerFetchResponseError | undefined;
+export interface SilenceZoomErrorConfig {
+    /**
+     * If true an error will be thrown if the meeting does not exist.
+     */
+    readonly silenceError?: boolean;
+}
+/**
+ * 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.
+ */
+export declare function omitSilenceZoomErrorKeys(options?: MakeUrlSearchParamsOptions): MakeUrlSearchParamsOptions;
+export type SilenceZoomErrorWithCodesFunction<T> = (silence?: boolean) => (reason: unknown) => T;
+/**
+ * Used with catch() to silence Zoom errors with the specified codes.
+ *
+ * For example, when deleting a meeting that does not exist, the error code is 3001. This function can be used to silence that error.
+ */
+export declare function silenceZoomErrorWithCodesFunction<T>(codes: ArrayOrValue<ZoomServerErrorCode>): SilenceZoomErrorWithCodesFunction<void>;
+export declare function silenceZoomErrorWithCodesFunction<T>(codes: ArrayOrValue<ZoomServerErrorCode>, returnFn: (error: ZoomServerFetchResponseError) => T): SilenceZoomErrorWithCodesFunction<T>;

package/src/lib/zoom.limit.d.ts

@@ -0,0 +1,37 @@
+import { Maybe, Milliseconds, PromiseOrValue, ResetPeriodPromiseRateLimiter } from '@dereekb/util';
+import { FetchResponseError, RateLimitedFetchHandler } from '@dereekb/util/fetch';
+import { ZoomRateLimitHeaderDetails } from './zoom.error.api';
+export interface ZoomRateLimiterRef {
+    readonly zoomRateLimiter: ResetPeriodPromiseRateLimiter;
+}
+/**
+ * Function to execute when too many requests is reached.
+ *
+ * Typically used for logging of some sort. Thrown errors are ignored.
+ */
+export type ZoomRateLimitedTooManyRequestsLogFunction = (headers: ZoomRateLimitHeaderDetails, response: Response, fetchResponseError?: FetchResponseError) => PromiseOrValue<void>;
+export declare const DEFAULT_ZOOM_RATE_LIMITED_TOO_MANY_REQUETS_LOG_FUNCTION: (headers: ZoomRateLimitHeaderDetails) => void;
+export interface ZoomRateLimitedFetchHandlerConfig {
+    /**
+     * Custom max rate limit.
+     *
+     * Rate limits are different between account types and are described here:
+     *
+     * https://help.zoom.com/portal/en/community/topic/key-changes-in-api-limits-26-9-2018#:~:text=X%2DRATELIMIT%2DREMAINING%20%2D%20Represents,time%20of%20the%20current%20window.&text=Please%20note%20that%20these%20Rate,API%20limit%20changes%20are%20implemented.
+     */
+    readonly maxRateLimit?: number;
+    /**
+     * Custom reset period for the rate limiter.
+     *
+     * Defaults to 1 minute in milliseconds.
+     */
+    readonly resetPeriod?: Milliseconds;
+    /**
+     * Optional function to execute when too many requests is reached.t
+     *
+     * Defaults to the default logging function, unless false is passed.
+     */
+    readonly onTooManyRequests?: ZoomRateLimitedTooManyRequestsLogFunction | false;
+}
+export type ZoomRateLimitedFetchHandler = RateLimitedFetchHandler<ResetPeriodPromiseRateLimiter>;
+export declare function zoomRateLimitedFetchHandler(config?: Maybe<ZoomRateLimitedFetchHandlerConfig>): ZoomRateLimitedFetchHandler;

package/src/lib/zoom.type.d.ts

@@ -0,0 +1,12 @@
+/**
+ * An identifier in Zoom.
+ */
+export type ZoomId = string;
+/**
+ * Zoom user identifier
+ */
+export type ZoomUserId = string;
+/**
+ * The version of the Zoom client used by the user.
+ */
+export type ZoomClientVersion = string;