@zoom/rivet
Version:
Zoom Rivet is a comprehensive toolkit built to help developers quickly integrate and manage server-side applications within the Zoom ecosystem. This tool currently supports Node.js, offering core functionalities like authentication, API wrappers, and even
1,391 lines (1,372 loc) • 259 kB
TypeScript
import { AxiosResponse } from 'axios';
import { LambdaFunctionURLResult, LambdaFunctionURLHandler } from 'aws-lambda';
import { Server } from 'node:http';
import { ServerOptions } from 'node:https';
declare enum LogLevel {
ERROR = "error",
WARN = "warn",
INFO = "info",
DEBUG = "debug"
}
interface Logger {
/**
* Output debug message
* @param msg any data to be logged
*/
debug(...msg: unknown[]): void;
/**
* Output info message
* @param msg any data to be logged
*/
info(...msg: unknown[]): void;
/**
* Output warn message
* @param msg any data to be logged
*/
warn(...msg: unknown[]): void;
/**
* Output error message
* @param msg any data to be logged
*/
error(...msg: unknown[]): void;
/**
* Disables all logging below the given level
* @param level as a string, 'error' | 'warn' | 'info' | 'debug'
*/
setLevel(level: LogLevel): void;
/**
* Return the current LogLevel.
*/
getLevel(): LogLevel;
/**
* Name the instance so that it can be filtered when many loggers are sending output
* to the same destination.
* @param name as a string
*/
setName(name: string): void;
}
declare class ConsoleLogger implements Logger {
private level;
private name;
private static labels;
private static severity;
constructor();
getLevel(): LogLevel;
setLevel(level: LogLevel): void;
setName(name: string): void;
debug(...msg: unknown[]): void;
info(...msg: unknown[]): void;
warn(...msg: unknown[]): void;
error(...msg: unknown[]): void;
private static isMoreOrEqualSevere;
}
type AllPropsOptional<T, True, False> = Exclude<{
[P in keyof T]: undefined extends T[P] ? True : False;
}[keyof T], undefined> extends True ? True : False;
type Constructor<T> = new (...args: any[]) => T;
type MaybeArray<T> = T | T[];
type MaybePromise<T> = T | Promise<T>;
type StringIndexed<V = any> = Record<string, V>;
interface TokenStore<Token> {
getLatestToken(): MaybePromise<Token | null | undefined>;
storeToken(token: Token): MaybePromise<void>;
}
interface AuthOptions<Token> {
clientId: string;
clientSecret: string;
tokenStore?: TokenStore<Token> | undefined;
logger?: Logger;
}
type OAuthGrantType = "authorization_code" | "client_credentials" | "refresh_token" | "account_credentials";
interface BaseOAuthRequest {
grant_type: OAuthGrantType;
}
interface OAuthAuthorizationCodeRequest extends BaseOAuthRequest {
code: string;
grant_type: "authorization_code";
redirect_uri?: string;
}
interface OAuthRefreshTokenRequest extends BaseOAuthRequest {
grant_type: "refresh_token";
refresh_token: string;
}
interface S2SAuthTokenRequest extends BaseOAuthRequest {
grant_type: "account_credentials";
account_id: string;
}
type OAuthRequest = OAuthAuthorizationCodeRequest | OAuthRefreshTokenRequest | S2SAuthTokenRequest;
/**
* {@link Auth} is the base implementation of authentication for Zoom's APIs.
*
* It only requires a `clientId` and `tokenStore`, as these options are shared across
* all authentication implementations, namely OAuth and server-to-server auth (client
* credentials, JWT, and server-to-server OAuth.)
*/
declare abstract class Auth<Token = unknown> {
protected readonly clientId: string;
protected readonly clientSecret: string;
protected readonly tokenStore: TokenStore<Token>;
protected readonly logger: Logger | undefined;
constructor({ clientId, clientSecret, tokenStore, logger }: AuthOptions<Token>);
protected getBasicAuthorization(): string;
abstract getToken(): MaybePromise<string>;
protected isAlmostExpired(isoTime: string): boolean;
protected makeOAuthTokenRequest<T extends OAuthGrantType>(grantType: T, payload?: Omit<Extract<OAuthRequest, {
grant_type: T;
}>, "grant_type">): Promise<AxiosResponse>;
}
interface ClientCredentialsToken {
accessToken: string;
expirationTimeIso: string;
scopes: string[];
}
interface JwtToken {
token: string;
expirationTimeIso: string;
}
interface S2SAuthToken {
accessToken: string;
expirationTimeIso: string;
scopes: string[];
}
interface S2SAuthOptions {
accountId: string;
}
declare class S2SAuth extends Auth<S2SAuthToken> {
private accountId;
constructor({ accountId, ...restOptions }: AuthOptions<S2SAuthToken> & S2SAuthOptions);
private assertRawToken;
private fetchAccessToken;
getToken(): Promise<string>;
private mapAccessToken;
}
interface Event<Type extends string> {
event: Type;
}
type EventKeys<T> = T extends Event<infer U> ? U : never;
type EventPayload<T, K> = Extract<T, {
event: K;
}>;
type EventListenerFn<Events, EventName extends EventKeys<Events>, ReturnType = MaybePromise<void>> = (payload: EventPayload<Events, EventName>) => ReturnType;
type EventListenerPredicateFn<Events, EventName extends EventKeys<Events>> = EventListenerFn<Events, EventName, MaybePromise<boolean>>;
type ContextListener<Events, EventName extends EventKeys<Events>, Context> = (_: EventPayload<Events, EventName> & Context) => MaybePromise<void>;
type GenericEventManager = EventManager<any, any>;
declare class EventManager<Endpoints, Events> {
protected endpoints: Endpoints;
constructor(endpoints: Endpoints);
private appendListener;
filteredEvent<EventName extends EventKeys<Events>>(eventName: EventName, predicate: EventListenerPredicateFn<Events, EventName>, listener: EventListenerFn<Events, EventName>): void;
emit<EventName extends EventKeys<Events>>(eventName: EventName, payload: EventPayload<Events, EventName>): Promise<void>;
event<EventName extends EventKeys<Events>>(eventName: EventName, listener: EventListenerFn<Events, EventName>): void;
protected withContext<EventName extends EventKeys<Events>, Context>(): ContextListener<Events, EventName, Context>;
}
declare enum StatusCode {
OK = 200,
TEMPORARY_REDIRECT = 302,
BAD_REQUEST = 400,
NOT_FOUND = 404,
METHOD_NOT_ALLOWED = 405,
INTERNAL_SERVER_ERROR = 500
}
interface ReceiverInitOptions {
eventEmitter?: GenericEventManager | undefined;
interactiveAuth?: InteractiveAuth | undefined;
}
interface Receiver {
canInstall(): true | false;
init(options: ReceiverInitOptions): void;
start(...args: any[]): MaybePromise<unknown>;
stop(...args: any[]): MaybePromise<unknown>;
}
interface HttpReceiverOptions extends Partial<SecureServerOptions> {
endpoints?: MaybeArray<string> | undefined;
logger?: Logger | undefined;
logLevel?: LogLevel | undefined;
port?: number | string | undefined;
webhooksSecretToken?: string | undefined;
}
type SecureServerOptions = {
[K in (typeof secureServerOptionKeys)[number]]: ServerOptions[K];
};
declare const secureServerOptionKeys: (keyof ServerOptions)[];
declare class HttpReceiver implements Receiver {
private eventEmitter?;
private interactiveAuth?;
private server?;
private logger;
constructor(options: HttpReceiverOptions);
canInstall(): true;
private buildDeletedStateCookieHeader;
private buildStateCookieHeader;
private getRequestCookie;
private getServerCreator;
private hasEndpoint;
private hasSecureOptions;
init({ eventEmitter, interactiveAuth }: ReceiverInitOptions): void;
private setResponseCookie;
private areNormalizedUrlsEqual;
start(port?: number | string): Promise<Server>;
stop(): Promise<void>;
private writeTemporaryRedirect;
private writeResponse;
}
interface BaseResponse<Data = unknown> {
data?: Data | undefined;
statusCode: number;
trackingId?: string | undefined;
}
interface BuildEndpointOptions<PathSchema> {
method: HttpMethod;
baseUrlOverride?: string | undefined;
urlPathBuilder: (params: PathSchema) => string;
requestMimeType?: RequestMimeType;
}
interface WebEndpointOptions {
auth: Auth;
baseUrl?: string | undefined;
doubleEncodeUrl?: boolean | undefined;
timeout?: number | undefined;
userAgentName?: string | undefined;
}
type EndpointArguments<PathSchema extends StringIndexed | NoParams, BodySchema extends StringIndexed | NoParams, QuerySchema extends StringIndexed | NoParams> = (PathSchema extends NoParams ? object : AllPropsOptional<PathSchema, "t", "f"> extends "t" ? {
path?: PathSchema;
} : {
path: PathSchema;
}) & (BodySchema extends NoParams ? object : AllPropsOptional<BodySchema, "t", "f"> extends "t" ? {
body?: BodySchema;
} : {
body: BodySchema;
}) & (QuerySchema extends NoParams ? object : AllPropsOptional<QuerySchema, "t", "f"> extends "t" ? {
query?: QuerySchema;
} : {
query: QuerySchema;
});
type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
type NoParams = "_NO_PARAMS_";
type RequestMimeType = "application/json" | "multipart/form-data";
declare class WebEndpoints {
constructor(options: WebEndpointOptions);
protected buildEndpoint<PathSchema extends StringIndexed | NoParams, BodySchema extends StringIndexed | NoParams, QuerySchema extends StringIndexed | NoParams, ResponseData = unknown>({ method, baseUrlOverride, urlPathBuilder, requestMimeType }: BuildEndpointOptions<PathSchema>): (_: EndpointArguments<PathSchema, BodySchema, QuerySchema>) => Promise<BaseResponse<ResponseData>>;
private buildUserAgent;
private getCustomUserAgentName;
private getHeaders;
private getRequestBody;
private isOk;
private isZoomResponseError;
private makeRequest;
}
type CommonClientOptions<A extends Auth, R extends Receiver> = GetAuthOptions<A> & ExtractInstallerOptions<A, R> & Pick<WebEndpointOptions, "userAgentName"> & {
disableReceiver?: boolean | undefined;
logger?: Logger | undefined;
logLevel?: LogLevel | undefined;
};
interface ClientReceiverOptions<R extends Receiver> {
receiver: R;
}
type ClientConstructorOptions<A extends Auth, O extends CommonClientOptions<A, R>, R extends Receiver> = (O & {
disableReceiver: true;
}) | (O & (ClientReceiverOptions<R> | HttpReceiverOptions));
type ExtractInstallerOptions<A extends Auth, R extends Receiver> = A extends InteractiveAuth ? [
ReturnType<R["canInstall"]>
] extends [true] ? WideInstallerOptions : object : object;
type ExtractAuthTokenType<A> = A extends Auth<infer T> ? T : never;
type GetAuthOptions<A extends Auth> = AuthOptions<ExtractAuthTokenType<A>> & (A extends S2SAuth ? S2SAuthOptions : object);
type WideInstallerOptions = {
installerOptions: InstallerOptions;
};
declare abstract class ProductClient<AuthType extends Auth, EndpointsType extends WebEndpoints, EventProcessorType extends GenericEventManager, OptionsType extends CommonClientOptions<AuthType, ReceiverType>, ReceiverType extends Receiver> {
private readonly auth;
readonly endpoints: EndpointsType;
readonly webEventConsumer?: EventProcessorType | undefined;
private readonly receiver?;
constructor(options: ClientConstructorOptions<AuthType, OptionsType, ReceiverType>);
protected abstract initAuth(options: OptionsType): AuthType;
protected abstract initEndpoints(auth: AuthType, options: OptionsType): EndpointsType;
protected abstract initEventProcessor(endpoints: EndpointsType, options: OptionsType): EventProcessorType | undefined;
private initDefaultReceiver;
start(): Promise<ReturnType<ReceiverType["start"]>>;
}
/**
* {@link StateStore} defines methods for generating and verifying OAuth state.
*
* This interface is implemented internally for the default state store; however,
* it can also be implemented and passed to an OAuth client as well.
*/
interface StateStore {
/**
* Generate a new state string, which is directly appended to the OAuth `state` parameter.
*/
generateState(): MaybePromise<string>;
/**
* Verify that the state received during OAuth callback is valid and not forged.
*
* If state verification fails, {@link OAuthStateVerificationFailedError} should be thrown.
*
* @param state The state parameter that was received during OAuth callback
*/
verifyState(state: string): MaybePromise<void>;
}
/**
* Guard if an object implements the {@link StateStore} interface — most notably,
* `generateState()` and `verifyState(state: string)`.
*/
declare const isStateStore: (obj: unknown) => obj is StateStore;
interface AuthorizationUrlResult {
fullUrl: string;
generatedState: string;
}
interface InstallerOptions {
directInstall?: boolean | undefined;
installPath?: string | undefined;
redirectUri: string;
redirectUriPath?: string | undefined;
stateStore: StateStore | string;
stateCookieName?: string | undefined;
stateCookieMaxAge?: number | undefined;
}
/**
* {@link InteractiveAuth}, an extension of {@link Auth}, is designed for use cases where authentication
* is initiated server-side, but requires manual authorization from a user, by redirecting the user to Zoom.
*
* In addition to all required fields from {@link AuthOptions}, this class requires a `redirectUri`, as this
* value is appended to the authorization URL when the user is redirected to Zoom and subsequently redirected
* back to an endpoint on this server.
*
* @see {@link https://developers.zoom.us/docs/integrations/oauth/ | OAuth - Zoom Developers}
*/
declare abstract class InteractiveAuth<Token = unknown> extends Auth<Token> {
installerOptions?: ReturnType<typeof this.setInstallerOptions>;
getAuthorizationUrl(): Promise<AuthorizationUrlResult>;
getFullRedirectUri(): string;
setInstallerOptions({ directInstall, installPath, redirectUri, redirectUriPath, stateStore, stateCookieName, stateCookieMaxAge }: InstallerOptions): {
directInstall: boolean;
installPath: string;
redirectUri: string;
redirectUriPath: string;
stateStore: StateStore;
stateCookieName: string;
stateCookieMaxAge: number;
};
}
/**
* Credentials for access token & refresh token, which are used to access Zoom's APIs.
*
* As access token is short-lived (usually a single hour), its expiration time is checked
* first. If it's possible to use the access token, it's used; however, if it has expired
* or is close to expiring, the refresh token should be used to generate a new access token
* before the API call is made. Refresh tokens are generally valid for 90 days.
*
* If neither the access token nor the refresh token is available, {@link OAuthTokenRefreshFailedError}
* shall be thrown, informing the developer that neither value can be used, and the user must re-authorize.
* It's likely that this error will be rare, but it _can_ be thrown.
*/
interface OAuthToken {
accessToken: string;
expirationTimeIso: string;
refreshToken: string;
scopes: string[];
}
declare class OAuth extends InteractiveAuth<OAuthToken> {
private assertResponseAccessToken;
private fetchAccessToken;
getToken(): Promise<string>;
initRedirectCode(code: string): Promise<void>;
private mapOAuthToken;
private refreshAccessToken;
}
interface RivetError<ErrorCode extends string = string> extends Error {
readonly errorCode: ErrorCode;
}
declare const isCoreError: <K extends "ApiResponseError" | "AwsReceiverRequestError" | "ClientCredentialsRawResponseError" | "S2SRawResponseError" | "CommonHttpRequestError" | "ReceiverInconsistentStateError" | "ReceiverOAuthFlowError" | "HTTPReceiverConstructionError" | "HTTPReceiverPortNotNumberError" | "HTTPReceiverRequestError" | "OAuthInstallerNotInitializedError" | "OAuthTokenDoesNotExistError" | "OAuthTokenFetchFailedError" | "OAuthTokenRawResponseError" | "OAuthTokenRefreshFailedError" | "OAuthStateVerificationFailedError" | "ProductClientConstructionError">(obj: unknown, key?: K | undefined) => obj is RivetError<{
readonly ApiResponseError: "zoom_rivet_api_response_error";
readonly AwsReceiverRequestError: "zoom_rivet_aws_receiver_request_error";
readonly ClientCredentialsRawResponseError: "zoom_rivet_client_credentials_raw_response_error";
readonly S2SRawResponseError: "zoom_rivet_s2s_raw_response_error";
readonly CommonHttpRequestError: "zoom_rivet_common_http_request_error";
readonly ReceiverInconsistentStateError: "zoom_rivet_receiver_inconsistent_state_error";
readonly ReceiverOAuthFlowError: "zoom_rivet_receiver_oauth_flow_error";
readonly HTTPReceiverConstructionError: "zoom_rivet_http_receiver_construction_error";
readonly HTTPReceiverPortNotNumberError: "zoom_rivet_http_receiver_port_not_number_error";
readonly HTTPReceiverRequestError: "zoom_rivet_http_receiver_request_error";
readonly OAuthInstallerNotInitializedError: "zoom_rivet_oauth_installer_not_initialized_error";
readonly OAuthTokenDoesNotExistError: "zoom_rivet_oauth_does_not_exist_error";
readonly OAuthTokenFetchFailedError: "zoom_rivet_oauth_token_fetch_failed_error";
readonly OAuthTokenRawResponseError: "zoom_rivet_oauth_token_raw_response_error";
readonly OAuthTokenRefreshFailedError: "zoom_rivet_oauth_token_refresh_failed_error";
readonly OAuthStateVerificationFailedError: "zoom_rivet_oauth_state_verification_failed_error";
readonly ProductClientConstructionError: "zoom_rivet_product_client_construction_error";
}[K]>;
declare const ApiResponseError: Constructor<Error>;
declare const AwsReceiverRequestError: Constructor<Error>;
declare const ClientCredentialsRawResponseError: Constructor<Error>;
declare const S2SRawResponseError: Constructor<Error>;
declare const CommonHttpRequestError: Constructor<Error>;
declare const ReceiverInconsistentStateError: Constructor<Error>;
declare const ReceiverOAuthFlowError: Constructor<Error>;
declare const HTTPReceiverConstructionError: Constructor<Error>;
declare const HTTPReceiverPortNotNumberError: Constructor<Error>;
declare const HTTPReceiverRequestError: Constructor<Error>;
declare const OAuthInstallerNotInitializedError: Constructor<Error>;
declare const OAuthTokenDoesNotExistError: Constructor<Error>;
declare const OAuthTokenFetchFailedError: Constructor<Error>;
declare const OAuthTokenRawResponseError: Constructor<Error>;
declare const OAuthTokenRefreshFailedError: Constructor<Error>;
declare const OAuthStateVerificationFailedError: Constructor<Error>;
declare const ProductClientConstructionError: Constructor<Error>;
interface AwsLambdaReceiverOptions {
webhooksSecretToken: string;
}
declare class AwsLambdaReceiver implements Receiver {
private eventEmitter?;
private readonly webhooksSecretToken;
constructor({ webhooksSecretToken }: AwsLambdaReceiverOptions);
buildResponse(statusCode: StatusCode, body: object): LambdaFunctionURLResult;
canInstall(): false;
init({ eventEmitter }: ReceiverInitOptions): void;
start(): LambdaFunctionURLHandler;
stop(): Promise<void>;
}
type ContactGroupsListContactGroupsQueryParams = {
page_size?: number;
next_page_token?: string;
};
type ContactGroupsListContactGroupsResponse = {
groups?: {
group_id?: string;
group_name?: string;
group_privacy?: 1 | 2 | 3;
description?: string;
}[];
next_page_token?: string;
page_size?: number;
};
type ContactGroupsCreateContactGroupRequestBody = {
group_name?: string;
group_privacy?: 1 | 2 | 3;
description?: string;
group_members?: {
type?: 1 | 2;
id?: string;
}[];
};
type ContactGroupsCreateContactGroupResponse = {
group_id?: string;
group_name?: string;
total_members?: number;
group_privacy?: 1 | 2 | 3;
description?: string;
};
type ContactGroupsGetContactGroupPathParams = {
groupId: string;
};
type ContactGroupsGetContactGroupResponse = {
group_id?: string;
group_name?: string;
total_members?: number;
group_privacy?: 1 | 2 | 3;
description?: string;
};
type ContactGroupsDeleteContactGroupPathParams = {
groupId: string;
};
type ContactGroupsUpdateContactGroupPathParams = {
groupId: string;
};
type ContactGroupsUpdateContactGroupRequestBody = {
name?: string;
privacy?: 1 | 2 | 3;
description?: string;
};
type ContactGroupsListContactGroupMembersPathParams = {
groupId: string;
};
type ContactGroupsListContactGroupMembersQueryParams = {
page_size?: number;
next_page_token?: string;
};
type ContactGroupsListContactGroupMembersResponse = {
group_members?: {
type?: 1 | 2;
id?: string;
name?: string;
}[];
next_page_token?: string;
page_size?: number;
};
type ContactGroupsAddContactGroupMembersPathParams = {
groupId: string;
};
type ContactGroupsAddContactGroupMembersRequestBody = {
group_members?: {
type?: 1 | 2;
id?: string;
}[];
};
type ContactGroupsAddContactGroupMembersResponse = {
member_ids?: string[];
};
type ContactGroupsRemoveMembersInContactGroupPathParams = {
groupId: string;
};
type ContactGroupsRemoveMembersInContactGroupQueryParams = {
member_ids: string;
};
type DivisionsListDivisionsQueryParams = {
next_page_token?: string;
page_size?: number;
};
type DivisionsListDivisionsResponse = {
next_page_token?: string;
page_size?: number;
total_records?: number;
divisions?: {
division_id?: string;
division_name?: string;
division_description?: string;
is_main_division?: boolean;
total_members?: number;
}[];
};
type DivisionsCreateDivisionRequestBody = {
division_name: string;
division_description?: string;
};
type DivisionsCreateDivisionResponse = {
division_id?: string;
division_name?: string;
division_description?: string;
};
type DivisionsGetDivisionPathParams = {
divisionId: string;
};
type DivisionsGetDivisionResponse = {
division_id?: string;
division_name?: string;
division_description?: string;
is_main_division?: boolean;
};
type DivisionsDeleteDivisionPathParams = {
divisionId: string;
};
type DivisionsUpdateDivisionPathParams = {
divisionId: string;
};
type DivisionsUpdateDivisionRequestBody = {
division_name?: string;
division_description?: string;
};
type DivisionsListDivisionMembersPathParams = {
divisionId: string;
};
type DivisionsListDivisionMembersQueryParams = {
next_page_token?: string;
page_size?: number;
};
type DivisionsListDivisionMembersResponse = {
next_page_token?: string;
page_size?: number;
total_records?: number;
users?: {
user_id?: string;
user_display_name?: string;
user_email?: string;
}[];
};
type DivisionsAssignDivisionPathParams = {
divisionId: string;
};
type DivisionsAssignDivisionRequestBody = {
users?: {
user_email?: string;
user_id?: string;
}[];
};
type DivisionsAssignDivisionResponse = {
added_at?: string;
ids?: string;
};
type GroupsListGroupsQueryParams = {
page_size?: number;
next_page_token?: string;
};
type GroupsListGroupsResponse = {
groups?: ({
id?: string;
} & {
name?: string;
total_members?: number;
})[];
total_records?: number;
next_page_token?: string;
};
type GroupsCreateGroupRequestBody = {
name?: string;
};
type GroupsCreateGroupResponse = {
id?: string;
name?: string;
total_members?: number;
};
type GroupsGetGroupPathParams = {
groupId: string;
};
type GroupsGetGroupResponse = {
id?: string;
name?: string;
total_members?: number;
};
type GroupsDeleteGroupPathParams = {
groupId: string;
};
type GroupsUpdateGroupPathParams = {
groupId: string;
};
type GroupsUpdateGroupRequestBody = {
name?: string;
};
type GroupsListGroupAdminsPathParams = {
groupId: string;
};
type GroupsListGroupAdminsQueryParams = {
page_size?: number;
next_page_token?: string;
};
type GroupsListGroupAdminsResponse = {
admins?: {
email?: string;
name?: string;
}[];
next_page_token?: string;
page_size?: number;
total_records?: number;
};
type GroupsAddGroupAdminsPathParams = {
groupId: string;
};
type GroupsAddGroupAdminsRequestBody = {
admins?: {
email?: string;
id?: string;
}[];
};
type GroupsAddGroupAdminsResponse = {
added_at?: string;
ids?: string;
};
type GroupsDeleteGroupAdminPathParams = {
groupId: string;
userId: string;
};
type GroupsListGroupChannelsPathParams = {
groupId: string;
};
type GroupsListGroupChannelsResponse = {
channels: {
channel_id: string;
channel_name: string;
member_count: number;
}[];
group_id: string;
};
type GroupsGetLockedSettingsPathParams = {
groupId: string;
};
type GroupsGetLockedSettingsQueryParams = {
option?: string;
};
type GroupsGetLockedSettingsResponse = {
audio_conferencing?: {
toll_free_and_fee_based_toll_call?: boolean;
};
email_notification?: {
alternative_host_reminder?: boolean;
cancel_meeting_reminder?: boolean;
cloud_recording_available_reminder?: boolean;
jbh_reminder?: boolean;
schedule_for_reminder?: boolean;
};
in_meeting?: {
alert_guest_join?: boolean;
allow_users_to_delete_messages_in_meeting_chat?: boolean;
allow_live_streaming?: boolean;
allow_show_zoom_windows?: boolean;
annotation?: boolean;
attendee_on_hold?: boolean;
auto_answer?: boolean;
auto_generated_captions?: boolean;
auto_saving_chat?: boolean;
breakout_room?: boolean;
chat?: boolean;
meeting_question_answer?: boolean;
closed_caption?: boolean;
co_host?: boolean;
custom_data_center_regions?: boolean;
disable_screen_sharing_for_host_meetings?: boolean;
disable_screen_sharing_for_in_meeting_guests?: boolean;
e2e_encryption?: boolean;
entry_exit_chime?: string;
far_end_camera_control?: boolean;
feedback?: boolean;
file_transfer?: boolean;
full_transcript?: boolean;
group_hd?: boolean;
webinar_group_hd?: boolean;
language_interpretation?: boolean;
sign_language_interpretation?: boolean;
manual_captions?: boolean;
meeting_reactions?: boolean;
webinar_reactions?: boolean;
meeting_survey?: boolean;
non_verbal_feedback?: boolean;
original_audio?: boolean;
polling?: boolean;
post_meeting_feedback?: boolean;
private_chat?: boolean;
remote_control?: boolean;
remote_support?: boolean;
request_permission_to_unmute_participants?: boolean;
save_caption?: boolean;
save_captions?: boolean;
screen_sharing?: boolean;
sending_default_email_invites?: boolean;
show_a_join_from_your_browser_link?: boolean;
show_browser_join_link?: boolean;
show_meeting_control_toolbar?: boolean;
slide_control?: boolean;
stereo_audio?: boolean;
use_html_format_email?: boolean;
virtual_background?: boolean;
waiting_room?: boolean;
webinar_chat?: boolean;
webinar_live_streaming?: boolean;
webinar_polling?: boolean;
webinar_question_answer?: boolean;
webinar_survey?: boolean;
whiteboard?: boolean;
};
other_options?: {
blur_snapshot?: boolean;
};
recording?: {
account_user_access_recording?: boolean;
auto_delete_cmr?: boolean;
auto_recording?: boolean;
cloud_recording?: boolean;
cloud_recording_download?: boolean;
host_delete_cloud_recording?: boolean;
ip_address_access_control?: {
enable?: boolean;
ip_addresses_or_ranges?: string;
};
local_recording?: boolean;
prevent_host_access_recording?: boolean;
recording_authentication?: boolean;
archive?: boolean;
};
schedule_meeting?: {
audio_type?: boolean;
embed_password_in_join_link?: boolean;
force_pmi_jbh_password?: boolean;
host_video?: boolean;
join_before_host?: boolean;
meeting_authentication?: boolean;
mute_upon_entry?: boolean;
participant_video?: boolean;
pstn_password_protected?: boolean;
require_password_for_instant_meetings?: boolean;
require_password_for_pmi_meetings?: boolean;
require_password_for_scheduling_new_meetings?: boolean;
upcoming_meeting_reminder?: boolean;
continuous_meeting_chat?: boolean;
};
telephony?: {
telephony_regions?: boolean;
third_party_audio?: boolean;
};
} | {
meeting_security?: {
approved_or_denied_countries_or_regions?: boolean;
auto_security?: boolean;
block_user_domain?: boolean;
embed_password_in_join_link?: boolean;
encryption_type?: "enhanced_encryption" | "e2ee";
end_to_end_encrypted_meetings?: boolean;
meeting_password?: boolean;
only_authenticated_can_join_from_webclient?: boolean;
phone_password?: boolean;
pmi_password?: boolean;
waiting_room?: boolean;
webinar_password?: boolean;
};
};
type GroupsUpdateLockedSettingsPathParams = {
groupId: string;
};
type GroupsUpdateLockedSettingsQueryParams = {
option?: string;
};
type GroupsUpdateLockedSettingsRequestBody = {
audio_conferencing?: {
toll_free_and_fee_based_toll_call?: boolean;
};
email_notification?: {
alternative_host_reminder?: boolean;
cancel_meeting_reminder?: boolean;
cloud_recording_available_reminder?: boolean;
jbh_reminder?: boolean;
schedule_for_reminder?: boolean;
};
in_meeting?: {
alert_guest_join?: boolean;
allow_users_to_delete_messages_in_meeting_chat?: boolean;
allow_live_streaming?: boolean;
allow_show_zoom_windows?: boolean;
annotation?: boolean;
attendee_on_hold?: boolean;
auto_answer?: boolean;
auto_generated_captions?: boolean;
auto_saving_chat?: boolean;
breakout_room?: boolean;
chat?: boolean;
meeting_question_answer?: boolean;
closed_caption?: boolean;
co_host?: boolean;
custom_data_center_regions?: boolean;
disable_screen_sharing_for_host_meetings?: boolean;
disable_screen_sharing_for_in_meeting_guests?: boolean;
e2e_encryption?: boolean;
entry_exit_chime?: string;
far_end_camera_control?: boolean;
feedback?: boolean;
file_transfer?: boolean;
full_transcript?: boolean;
group_hd?: boolean;
webinar_group_hd?: boolean;
language_interpretation?: boolean;
sign_language_interpretation?: boolean;
webinar_reactions?: boolean;
meeting_survey?: boolean;
non_verbal_feedback?: boolean;
original_audio?: boolean;
polling?: boolean;
post_meeting_feedback?: boolean;
private_chat?: boolean;
remote_control?: boolean;
remote_support?: boolean;
request_permission_to_unmute_participants?: boolean;
save_caption?: boolean;
save_captions?: boolean;
screen_sharing?: boolean;
sending_default_email_invites?: boolean;
show_a_join_from_your_browser_link?: boolean;
show_browser_join_link?: boolean;
show_meeting_control_toolbar?: boolean;
slide_control?: boolean;
stereo_audio?: boolean;
use_html_format_email?: boolean;
virtual_background?: boolean;
waiting_room?: boolean;
webinar_chat?: boolean;
webinar_live_streaming?: boolean;
webinar_polling?: boolean;
webinar_question_answer?: boolean;
webinar_survey?: boolean;
whiteboard?: boolean;
};
other_options?: {
blur_snapshot?: boolean;
};
recording?: {
account_user_access_recording?: boolean;
auto_delete_cmr?: boolean;
auto_recording?: boolean;
cloud_recording?: boolean;
cloud_recording_download?: boolean;
host_delete_cloud_recording?: boolean;
ip_address_access_control?: {
enable?: boolean;
ip_addresses_or_ranges?: string;
};
local_recording?: boolean;
recording_authentication?: boolean;
archive?: boolean;
};
schedule_meeting?: {
audio_type?: boolean;
embed_password_in_join_link?: boolean;
force_pmi_jbh_password?: boolean;
host_video?: boolean;
join_before_host?: boolean;
meeting_authentication?: boolean;
mute_upon_entry?: boolean;
participant_video?: boolean;
personal_meeting?: boolean;
pstn_password_protected?: boolean;
require_password_for_instant_meetings?: boolean;
require_password_for_pmi_meetings?: boolean;
require_password_for_scheduling_new_meetings?: boolean;
upcoming_meeting_reminder?: boolean;
continuous_meeting_chat?: boolean;
};
telephony?: {
telephony_regions?: boolean;
third_party_audio?: boolean;
};
} | {
meeting_security?: {
approved_or_denied_countries_or_regions?: boolean;
auto_security?: boolean;
block_user_domain?: boolean;
embed_password_in_join_link?: boolean;
encryption_type?: "enhanced_encryption" | "e2ee";
end_to_end_encrypted_meetings?: boolean;
meeting_password?: boolean;
only_authenticated_can_join_from_webclient?: boolean;
phone_password?: boolean;
pmi_password?: boolean;
waiting_room?: boolean;
webinar_password?: boolean;
};
};
type GroupsListGroupMembersPathParams = {
groupId: string;
};
type GroupsListGroupMembersQueryParams = {
page_size?: number;
page_number?: number;
next_page_token?: string;
};
type GroupsListGroupMembersResponse = {
members?: {
email?: string;
first_name?: string;
id?: string;
last_name?: string;
type?: number;
}[];
next_page_token?: string;
page_count?: number;
page_number?: number;
page_size?: number;
total_records?: number;
};
type GroupsAddGroupMembersPathParams = {
groupId: string;
};
type GroupsAddGroupMembersRequestBody = {
members?: {
email?: string;
id?: string;
}[];
};
type GroupsAddGroupMembersResponse = {
added_at?: string;
ids?: string;
};
type GroupsDeleteGroupMemberPathParams = {
groupId: string;
memberId: string;
};
type GroupsUpdateGroupMemberPathParams = {
groupId: string;
memberId: string;
};
type GroupsUpdateGroupMemberRequestBody = {
action: "move" | "set_primary";
target_group_id?: string;
};
type GroupsGetGroupsSettingsPathParams = {
groupId: string;
};
type GroupsGetGroupsSettingsQueryParams = {
option?: "meeting_authentication" | "recording_authentication" | "meeting_security";
custom_query_fields?: string;
};
type GroupsGetGroupsSettingsResponse = {
audio_conferencing?: {
toll_free_and_fee_based_toll_call?: {
allow_webinar_attendees_dial?: boolean;
enable?: boolean;
numbers?: {
code?: string;
country_code?: string;
country_name?: string;
display_number?: string;
number?: string;
}[];
};
};
email_notification?: {
alternative_host_reminder?: boolean;
cancel_meeting_reminder?: boolean;
cloud_recording_available_reminder?: boolean;
jbh_reminder?: boolean;
recording_available_reminder_alternative_hosts?: boolean;
recording_available_reminder_schedulers?: boolean;
schedule_for_reminder?: boolean;
};
in_meeting?: {
alert_guest_join?: boolean;
allow_users_to_delete_messages_in_meeting_chat?: boolean;
allow_live_streaming?: boolean;
allow_participants_chat_with?: 1 | 2 | 3 | 4;
allow_show_zoom_windows?: boolean;
allow_users_save_chats?: 1 | 2 | 3;
annotation?: boolean;
attendee_on_hold?: boolean;
auto_answer?: boolean;
auto_saving_chat?: boolean;
breakout_room?: boolean;
breakout_room_schedule?: boolean;
chat?: boolean;
meeting_question_answer?: boolean;
closed_caption?: boolean;
closed_captioning?: {
auto_transcribing?: boolean;
enable?: boolean;
save_caption?: boolean;
third_party_captioning_service?: boolean;
view_full_transcript?: boolean;
};
co_host?: boolean;
custom_data_center_regions?: boolean;
custom_live_streaming_service?: boolean;
custom_service_instructions?: string;
data_center_regions?: ("AU" | "LA" | "CA" | "CN" | "DE" | "HK" | "IN" | "IE" | "TY" | "MX" | "NL" | "SG" | "US")[];
disable_screen_sharing_for_host_meetings?: boolean;
disable_screen_sharing_for_in_meeting_guests?: boolean;
e2e_encryption?: boolean;
entry_exit_chime?: string;
far_end_camera_control?: boolean;
feedback?: boolean;
file_transfer?: boolean;
group_hd?: boolean;
webinar_group_hd?: boolean;
join_from_desktop?: boolean;
join_from_mobile?: boolean;
auto_generated_translation?: {
language_item_pairList?: {
trans_lang_config?: {
speak_language?: {
name?: "Chinese (Simplified)" | "Dutch" | "English" | "French" | "German" | "Italian" | "Japanese" | "Korean" | "Portuguese" | "Russian" | "Spanish" | "Ukrainian";
code?: "zh" | "nl" | "en" | "fr" | "de" | "it" | "ja" | "ko" | "pt" | "ru" | "es" | "uk";
};
translate_to?: {
all?: boolean;
language_config?: {
name?: "English";
code?: "en";
}[];
};
}[];
all?: boolean;
};
enable?: boolean;
};
language_interpretation?: {
custom_languages?: string[];
enable_language_interpretation_by_default?: boolean;
allow_participants_to_speak_in_listening_channel?: boolean;
allow_up_to_25_custom_languages_when_scheduling_meetings?: boolean;
enable?: boolean;
languages?: string[];
};
sign_language_interpretation?: {
enable?: boolean;
enable_sign_language_interpretation_by_default?: boolean;
languages?: ("American" | "Chinese" | "French" | "German" | "Japanese" | "Russian" | "Brazilian" | "Spanish" | "Mexican" | "British")[];
custom_languages?: string[];
};
live_streaming_facebook?: boolean;
live_streaming_youtube?: boolean;
manual_captioning?: {
allow_to_type?: boolean;
auto_generated_captions?: boolean;
full_transcript?: boolean;
manual_captions?: boolean;
save_captions?: boolean;
third_party_captioning_service?: boolean;
};
meeting_reactions?: boolean;
meeting_reactions_emojis?: "all" | "selected";
allow_host_panelists_to_use_audible_clap?: boolean;
webinar_reactions?: boolean;
meeting_survey?: boolean;
non_verbal_feedback?: boolean;
only_host_view_device_list?: boolean;
original_audio?: boolean;
polling?: boolean;
post_meeting_feedback?: boolean;
private_chat?: boolean;
record_play_own_voice?: boolean;
remote_control?: boolean;
remote_support?: boolean;
request_permission_to_unmute_participants?: boolean;
screen_sharing?: boolean;
sending_default_email_invites?: boolean;
show_a_join_from_your_browser_link?: boolean;
show_browser_join_link?: boolean;
show_device_list?: boolean;
show_meeting_control_toolbar?: boolean;
slide_control?: boolean;
stereo_audio?: boolean;
unchecked_data_center_regions?: string[];
use_html_format_email?: boolean;
virtual_background?: boolean;
virtual_background_settings?: {
allow_upload_custom?: boolean;
allow_videos?: boolean;
enable?: boolean;
files?: {
id?: string;
is_default?: boolean;
name?: string;
size?: number;
type?: string;
}[];
};
waiting_room?: boolean;
webinar_chat?: {
allow_attendees_chat_with?: 1 | 2 | 3;
allow_auto_save_local_chat_file?: boolean;
allow_panelists_chat_with?: 1 | 2;
allow_panelists_send_direct_message?: boolean;
allow_users_save_chats?: 0 | 1 | 2;
default_attendees_chat_with?: 1 | 2;
enable?: boolean;
};
webinar_live_streaming?: {
custom_service_instructions?: string;
enable?: boolean;
live_streaming_reminder?: boolean;
live_streaming_service?: ("facebook" | "workplace_by_facebook" | "youtube" | "custom_live_streaming_service")[];
};
meeting_polling?: {
enable?: boolean;
advanced_polls?: boolean;
manage_saved_polls_and_quizzes?: boolean;
require_answers_to_be_anonymous?: boolean;
allow_alternative_host_to_add_edit?: boolean;
allow_host_to_upload_image?: boolean;
};
webinar_polling?: {
enable?: boolean;
advanced_polls?: boolean;
manage_saved_polls_and_quizzes?: boolean;
require_answers_to_be_anonymous?: boolean;
allow_host_to_upload_image?: boolean;
allow_alternative_host_to_add_edit?: boolean;
};
webinar_question_answer?: boolean;
webinar_survey?: boolean;
whiteboard?: boolean;
who_can_share_screen?: "host" | "all";
who_can_share_screen_when_someone_is_sharing?: "host" | "all";
participants_share_simultaneously?: "multiple" | "one";
workplace_by_facebook?: boolean;
};
other_options?: {
allow_users_contact_support_via_chat?: boolean;
blur_snapshot?: boolean;
webinar_registration_options?: {
allow_host_to_enable_join_info?: boolean;
allow_host_to_enable_social_share_buttons?: boolean;
enable_custom_questions?: boolean;
};
};
profile?: {
recording_storage_location?: {
allowed_values?: string[];
value?: string;
};
};
recording?: {
account_user_access_recording?: boolean;
archive?: {
enable?: boolean;
settings?: {
audio_file?: boolean;
cc_transcript_file?: boolean;
chat_file?: boolean;
chat_with_sender_email?: boolean;
video_file?: boolean;
chat_with_direct_message?: boolean;
archive_retention?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30;
action_when_archive_failed?: 1 | 2;
notification_when_archiving_starts?: "participants" | "guest";
play_voice_prompt_when_archiving_starts?: "participants" | "guest" | "none";
};
type?: 1 | 2 | 3;
};
auto_recording?: string;
cloud_recording?: boolean;
cloud_recording_download?: boolean;
cloud_recording_download_host?: boolean;
host_delete_cloud_recording?: boolean;
record_files_separately?: {
active_speaker?: boolean;
gallery_view?: boolean;
shared_screen?: boolean;
};
display_participant_name?: boolean;
recording_thumbnails?: boolean;
optimize_recording_for_3rd_party_video_editor?: boolean;
recording_highlight?: boolean;
save_panelist_chat?: boolean;
save_poll_results?: boolean;
save_close_caption?: boolean;
ip_address_access_control?: {
enable?: boolean;
ip_addresses_or_ranges?: string;
};
local_recording?: boolean;
prevent_host_access_recording?: boolean;
record_audio_file?: boolean;
record_gallery_view?: boolean;
record_speaker_view?: boolean;
recording_audio_transcript?: boolean;
smart_recording?: {
create_recording_highlights?: boolean;
create_smart_chapters?: boolean;
create_next_steps?: boolean;
};
save_chat_text?: boolean;
show_timestamp?: boolean;
};
schedule_meeting?: {
audio_type?: string;
embed_password_in_join_link?: boolean;
force_pmi_jbh_password?: boolean;
host_video?: boolean;
join_before_host?: boolean;
mute_upon_entry?: boolean;
participant_video?: boolean;
personal_meeting?: boolean;
pstn_password_protected?: boolean;
require_password_for_instant_meetings?: boolean;
require_password_for_pmi_meetings?: "all" | "jbh_only" | "none";
require_password_for_scheduled_meetings?: boolean;
require_password_for_scheduling_new_meetings?: boolean;
upcoming_meeting_reminder?: boolean;
use_pmi_for_instant_meetings?: boolean;
use_pmi_for_schedule_meetings?: boolean;
always_display_zoom_meeting_as_topic?: {
enable?: boolean;
display_topic_for_scheduled_meetings?: boolean;
};
always_display_zoom_webinar_as_topic?: {
enable?: boolean;
display_topic_for_scheduled_webinars?: boolean;
};
continuous_meeting_chat?: {
enable?: boolean;
can_add_external_users?: boolean;
auto_add_invited_external_users?: boolean;
};
};
telephony?: {
audio_conference_info?: string;
telephony_regions?: {
selection_values?: string;
};
third_party_audio?: boolean;
};
chat?: {
share_files?: {
enable?: boolean;
share_option?: "anyone" | "account" | "organization";
};
chat_emojis?: {
enable?: boolean;
emojis_option?: "all" | "selected";
};
record_voice_messages?: boolean;
record_video_messages?: boolean;
screen_capture?: boolean;
create_public_channels?: boolean;
create_private_channels?: boolean;
share_links_in_chat?: boolean;
schedule_meetings_in_chat?: boolean;
set_retention_period_in_cloud?: {
enable?: boolean;
retention_period_of_direct_messages_and_group_conversation?: string;
retention_period_of_channels?: string;
};
set_retention_period_in_local?: {
enable?: boolean;
retention_period_of_direct_messages_and_group_conversation?: string;
retention_period_of_channels?: string;
};
allow_users_to_search_others_options?: string;
allow_users_to_add_contacts?: {
enable?: boolean;
selected_option?: 1 | 2 | 3 | 4;
user_email_addresses?: string;
};
allow_users_to_chat_with_others?: {
enable?: boolean;
selected_option?: 1 | 2 | 3 | 4;
user_email_addresses?: string;
};
chat_etiquette_tool?: {
enable?: boolean;
policies?: {
description?: string;
id?: string;
is_locked?: boolean;
keywords?: string[];
name?: string;
regular_expression?: string;
status?: "activated" | "deactivated";
trigger_action?: 1 | 2;
}[];
};
send_data_to_third_party_archiving_service?: {
enable?: boolean;
};
translate_messages?: boolean;
search_and_send_animated_gif_images?: {
enable?: boolean;
};
};
} | ({
allow_authentication_exception?: boolean;
authentication_options?: {
default_option?: boolean;
domains?: string;
id?: string;
name?: string;
type?: "enforce_login" | "enforce_login_with_same_account" | "enforce_login_with_domains";
visible?: boolean;
}[];
meeting_authentication?: boolean;
} | {
authentication_options?: {
default_option?: boolean;
domains?: string;
id?: string;
name?: string;
type?: "internally" | "enforce_login" | "enforce_login_with_domains";
visible?: boolean;
}[];
recording_authentication?: boolean;
}) | {
meeting_security?: {
auto_security?: boolean;
block_user_domain?: boolean;
block_user_domain_list?: string[];
chat_etiquette_tool?: {
enable?: boolean;
policies?: {
description?: string;
id?: string;
is_locked?: boolean;
keywords?: string[];
name?: string;
regular_expression?: string;
status?: "activated" | "deactivated";
trigger_action?: 1 | 2;
}[];
};
embed_password_in_join_link?: boolean;
encryption_type?: "enhanced_