@meeting-baas/sdk/dist/index.mjs

Official SDK for Meeting BaaS API - https://meetingbaas.com

#!/usr/bin/env node
var __defProp = Object.defineProperty;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __esm = (fn, res) => function __init() {
  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
};
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};

// src/generated/api/calendars/calendars.zod.ts
var calendars_zod_exports = {};
__export(calendars_zod_exports, {
  createCalendarBody: () => createCalendarBody,
  createCalendarResponse: () => createCalendarResponse,
  deleteCalendarParams: () => deleteCalendarParams,
  getCalendarParams: () => getCalendarParams,
  getCalendarResponse: () => getCalendarResponse,
  getEventParams: () => getEventParams,
  getEventResponse: () => getEventResponse,
  listCalendarsResponse: () => listCalendarsResponse,
  listCalendarsResponseItem: () => listCalendarsResponseItem,
  listEventsQueryParams: () => listEventsQueryParams,
  listEventsResponse: () => listEventsResponse,
  listRawCalendarsBody: () => listRawCalendarsBody,
  listRawCalendarsResponse: () => listRawCalendarsResponse,
  patchBotBody: () => patchBotBody,
  patchBotBodyBotImageDefault: () => patchBotBodyBotImageDefault,
  patchBotBodyDeduplicationKeyDefault: () => patchBotBodyDeduplicationKeyDefault,
  patchBotBodyEnterMessageDefault: () => patchBotBodyEnterMessageDefault,
  patchBotBodyExtraDefault: () => patchBotBodyExtraDefault,
  patchBotBodyNooneJoinedTimeoutDefault: () => patchBotBodyNooneJoinedTimeoutDefault,
  patchBotBodySpeechToTextDefault: () => patchBotBodySpeechToTextDefault,
  patchBotBodyStreamingAudioFrequencyDefault: () => patchBotBodyStreamingAudioFrequencyDefault,
  patchBotBodyStreamingInputDefault: () => patchBotBodyStreamingInputDefault,
  patchBotBodyStreamingOutputDefault: () => patchBotBodyStreamingOutputDefault,
  patchBotBodyTranscriptionCustomParametersDefault: () => patchBotBodyTranscriptionCustomParametersDefault,
  patchBotBodyWaitingRoomTimeoutDefault: () => patchBotBodyWaitingRoomTimeoutDefault,
  patchBotBodyZoomSdkIdDefault: () => patchBotBodyZoomSdkIdDefault,
  patchBotBodyZoomSdkPwdDefault: () => patchBotBodyZoomSdkPwdDefault,
  patchBotParams: () => patchBotParams,
  patchBotQueryParams: () => patchBotQueryParams,
  patchBotResponse: () => patchBotResponse,
  patchBotResponseItem: () => patchBotResponseItem,
  resyncAllResponse: () => resyncAllResponse,
  resyncAllResponseErrorsItemMax: () => resyncAllResponseErrorsItemMax,
  resyncAllResponseErrorsItemMin: () => resyncAllResponseErrorsItemMin,
  scheduleRecordEventBody: () => scheduleRecordEventBody,
  scheduleRecordEventParams: () => scheduleRecordEventParams,
  scheduleRecordEventQueryParams: () => scheduleRecordEventQueryParams,
  scheduleRecordEventResponse: () => scheduleRecordEventResponse,
  scheduleRecordEventResponseItem: () => scheduleRecordEventResponseItem,
  unscheduleRecordEventParams: () => unscheduleRecordEventParams,
  unscheduleRecordEventQueryParams: () => unscheduleRecordEventQueryParams,
  unscheduleRecordEventResponse: () => unscheduleRecordEventResponse,
  unscheduleRecordEventResponseItem: () => unscheduleRecordEventResponseItem,
  updateCalendarBody: () => updateCalendarBody,
  updateCalendarParams: () => updateCalendarParams,
  updateCalendarResponse: () => updateCalendarResponse
});
import { z as zod } from "zod";
var resyncAllResponseErrorsItemMin, resyncAllResponseErrorsItemMax, resyncAllResponse, listRawCalendarsBody, listRawCalendarsResponse, listCalendarsResponseItem, listCalendarsResponse, createCalendarBody, createCalendarResponse, getCalendarParams, getCalendarResponse, deleteCalendarParams, updateCalendarParams, updateCalendarBody, updateCalendarResponse, getEventParams, getEventResponse, scheduleRecordEventParams, scheduleRecordEventQueryParams, scheduleRecordEventBody, scheduleRecordEventResponseItem, scheduleRecordEventResponse, unscheduleRecordEventParams, unscheduleRecordEventQueryParams, unscheduleRecordEventResponseItem, unscheduleRecordEventResponse, patchBotParams, patchBotQueryParams, patchBotBodyBotImageDefault, patchBotBodyDeduplicationKeyDefault, patchBotBodyEnterMessageDefault, patchBotBodyExtraDefault, patchBotBodyNooneJoinedTimeoutDefault, patchBotBodySpeechToTextDefault, patchBotBodyStreamingAudioFrequencyDefault, patchBotBodyStreamingInputDefault, patchBotBodyStreamingOutputDefault, patchBotBodyTranscriptionCustomParametersDefault, patchBotBodyWaitingRoomTimeoutDefault, patchBotBodyZoomSdkIdDefault, patchBotBodyZoomSdkPwdDefault, patchBotBody, patchBotResponseItem, patchBotResponse, listEventsQueryParams, listEventsResponse;
var init_calendars_zod = __esm({
  "src/generated/api/calendars/calendars.zod.ts"() {
    "use strict";
    resyncAllResponseErrorsItemMin = 2;
    resyncAllResponseErrorsItemMax = 2;
    resyncAllResponse = zod.object({
      errors: zod.array(
        zod.array(zod.record(zod.string(), zod.any())).min(resyncAllResponseErrorsItemMin).max(resyncAllResponseErrorsItemMax)
      ).describe("List of calendar UUIDs that failed to resync, with error messages"),
      synced_calendars: zod.array(zod.string().uuid()).describe("List of calendar UUIDs that were successfully resynced")
    });
    listRawCalendarsBody = zod.object({
      oauth_client_id: zod.string(),
      oauth_client_secret: zod.string(),
      oauth_refresh_token: zod.string(),
      platform: zod.enum(["Google", "Microsoft"]).describe(
        'Fields with value `"simple"` parse as `Kind::Simple`. Fields with value `"fancy"` parse as `Kind::SoFancy`.'
      )
    });
    listRawCalendarsResponse = zod.object({
      calendars: zod.array(
        zod.object({
          email: zod.string(),
          id: zod.string(),
          is_primary: zod.boolean()
        })
      )
    });
    listCalendarsResponseItem = zod.object({
      email: zod.string(),
      google_id: zod.string(),
      name: zod.string(),
      resource_id: zod.string().nullish(),
      uuid: zod.string().uuid()
    });
    listCalendarsResponse = zod.array(listCalendarsResponseItem);
    createCalendarBody = zod.object({
      oauth_client_id: zod.string(),
      oauth_client_secret: zod.string(),
      oauth_refresh_token: zod.string(),
      platform: zod.enum(["Google", "Microsoft"]).describe(
        'Fields with value `"simple"` parse as `Kind::Simple`. Fields with value `"fancy"` parse as `Kind::SoFancy`.'
      ),
      raw_calendar_id: zod.string().nullish()
    });
    createCalendarResponse = zod.object({
      calendar: zod.object({
        email: zod.string(),
        google_id: zod.string(),
        name: zod.string(),
        resource_id: zod.string().nullish(),
        uuid: zod.string().uuid()
      })
    });
    getCalendarParams = zod.object({
      uuid: zod.string().describe("The UUID identifier")
    });
    getCalendarResponse = zod.object({
      email: zod.string(),
      google_id: zod.string(),
      name: zod.string(),
      resource_id: zod.string().nullish(),
      uuid: zod.string().uuid()
    });
    deleteCalendarParams = zod.object({
      uuid: zod.string().describe("The UUID identifier")
    });
    updateCalendarParams = zod.object({
      uuid: zod.string().describe("The UUID identifier")
    });
    updateCalendarBody = zod.object({
      oauth_client_id: zod.string(),
      oauth_client_secret: zod.string(),
      oauth_refresh_token: zod.string(),
      platform: zod.enum(["Google", "Microsoft"]).describe(
        'Fields with value `"simple"` parse as `Kind::Simple`. Fields with value `"fancy"` parse as `Kind::SoFancy`.'
      )
    });
    updateCalendarResponse = zod.object({
      calendar: zod.object({
        email: zod.string(),
        google_id: zod.string(),
        name: zod.string(),
        resource_id: zod.string().nullish(),
        uuid: zod.string().uuid()
      })
    });
    getEventParams = zod.object({
      uuid: zod.string().describe("The UUID identifier")
    });
    getEventResponse = zod.object({
      attendees: zod.array(
        zod.object({
          email: zod.string().describe("The email address of the meeting attendee"),
          name: zod.string().nullish().describe(
            "The display name of the attendee if available from the calendar provider (Google, Microsoft)"
          )
        })
      ),
      bot_param: zod.object({
        bot_image: zod.string().nullish(),
        bot_name: zod.string(),
        deduplication_key: zod.string().nullish(),
        enter_message: zod.string().nullish(),
        extra: zod.record(zod.string(), zod.any()).describe("Custom data object"),
        noone_joined_timeout: zod.number().nullish(),
        recording_mode: zod.enum(["speaker_view"]).describe("Records the active speaker view").or(
          zod.enum(["gallery_view"]).describe("Records the gallery view showing multiple participants")
        ).or(zod.enum(["audio_only"]).describe("Records only the audio from the meeting")).describe("Recording mode for the bot").or(zod.null()).optional(),
        speech_to_text_api_key: zod.string().nullish(),
        speech_to_text_provider: zod.enum(["Gladia", "Runpod", "Default"]).or(zod.null()).optional(),
        streaming_audio_frequency: zod.enum(["16khz", "24khz"]).or(zod.null()).optional(),
        streaming_input: zod.string().nullish(),
        streaming_output: zod.string().nullish(),
        transcription_custom_parameters: zod.record(zod.string(), zod.any()).describe("Custom data object"),
        waiting_room_timeout: zod.number().nullish(),
        webhook_url: zod.string(),
        zoom_sdk_id: zod.string().nullish(),
        zoom_sdk_pwd: zod.string().nullish()
      }).or(zod.null()).optional().describe("Associated bot parameters if a bot is scheduled for this event"),
      calendar_uuid: zod.string().uuid(),
      deleted: zod.boolean().describe("Indicates whether this event has been deleted"),
      end_time: zod.string().datetime({}).describe("The end time of the event in UTC timezone"),
      google_id: zod.string().describe("The unique identifier of the event from the calendar provider (Google, Microsoft)"),
      is_organizer: zod.boolean().describe("Indicates whether the current user is the organizer of this event"),
      is_recurring: zod.boolean().describe("Indicates whether this event is part of a recurring series"),
      last_updated_at: zod.string().datetime({}).describe("The timestamp when this event was last updated"),
      meeting_url: zod.string().describe("The URL that can be used to join the meeting (if available)"),
      name: zod.string().describe("The title/name of the calendar event"),
      raw: zod.record(zod.string(), zod.any()).describe("Custom data object"),
      recurring_event_id: zod.string().nullish().describe("For recurring events, the ID of the parent recurring event series (if applicable)"),
      start_time: zod.string().datetime({}).describe("The start time of the event in UTC timezone"),
      uuid: zod.string().uuid()
    });
    scheduleRecordEventParams = zod.object({
      uuid: zod.string().describe("The UUID identifier")
    });
    scheduleRecordEventQueryParams = zod.object({
      all_occurrences: zod.boolean().nullish().describe("schedule a bot to all occurences of a recurring event")
    });
    scheduleRecordEventBody = zod.object({
      bot_image: zod.string().nullish(),
      bot_name: zod.string(),
      deduplication_key: zod.string().nullish(),
      enter_message: zod.string().nullish(),
      extra: zod.record(zod.string(), zod.any()).describe("Custom data object"),
      noone_joined_timeout: zod.number().nullish(),
      recording_mode: zod.enum(["speaker_view"]).describe("Records the active speaker view").or(
        zod.enum(["gallery_view"]).describe("Records the gallery view showing multiple participants")
      ).or(zod.enum(["audio_only"]).describe("Records only the audio from the meeting")).describe("Recording mode for the bot").or(zod.null()).optional(),
      speech_to_text: zod.object({
        api_key: zod.string().nullish(),
        provider: zod.enum(["Gladia", "Runpod", "Default"])
      }).or(zod.enum(["Gladia", "Runpod", "Default"])).or(zod.null()).optional(),
      streaming_audio_frequency: zod.enum(["16khz", "24khz"]).or(zod.null()).optional(),
      streaming_input: zod.string().nullish(),
      streaming_output: zod.string().nullish(),
      transcription_custom_parameters: zod.record(zod.string(), zod.any()).optional().describe("Custom data object"),
      waiting_room_timeout: zod.number().nullish(),
      webhook_url: zod.string().nullish(),
      zoom_sdk_id: zod.string().nullish(),
      zoom_sdk_pwd: zod.string().nullish()
    });
    scheduleRecordEventResponseItem = zod.object({
      attendees: zod.array(
        zod.object({
          email: zod.string().describe("The email address of the meeting attendee"),
          name: zod.string().nullish().describe(
            "The display name of the attendee if available from the calendar provider (Google, Microsoft)"
          )
        })
      ),
      bot_param: zod.object({
        bot_image: zod.string().nullish(),
        bot_name: zod.string(),
        deduplication_key: zod.string().nullish(),
        enter_message: zod.string().nullish(),
        extra: zod.record(zod.string(), zod.any()).describe("Custom data object"),
        noone_joined_timeout: zod.number().nullish(),
        recording_mode: zod.enum(["speaker_view"]).describe("Records the active speaker view").or(
          zod.enum(["gallery_view"]).describe("Records the gallery view showing multiple participants")
        ).or(zod.enum(["audio_only"]).describe("Records only the audio from the meeting")).describe("Recording mode for the bot").or(zod.null()).optional(),
        speech_to_text_api_key: zod.string().nullish(),
        speech_to_text_provider: zod.enum(["Gladia", "Runpod", "Default"]).or(zod.null()).optional(),
        streaming_audio_frequency: zod.enum(["16khz", "24khz"]).or(zod.null()).optional(),
        streaming_input: zod.string().nullish(),
        streaming_output: zod.string().nullish(),
        transcription_custom_parameters: zod.record(zod.string(), zod.any()).describe("Custom data object"),
        waiting_room_timeout: zod.number().nullish(),
        webhook_url: zod.string(),
        zoom_sdk_id: zod.string().nullish(),
        zoom_sdk_pwd: zod.string().nullish()
      }).or(zod.null()).optional().describe("Associated bot parameters if a bot is scheduled for this event"),
      calendar_uuid: zod.string().uuid(),
      deleted: zod.boolean().describe("Indicates whether this event has been deleted"),
      end_time: zod.string().datetime({}).describe("The end time of the event in UTC timezone"),
      google_id: zod.string().describe("The unique identifier of the event from the calendar provider (Google, Microsoft)"),
      is_organizer: zod.boolean().describe("Indicates whether the current user is the organizer of this event"),
      is_recurring: zod.boolean().describe("Indicates whether this event is part of a recurring series"),
      last_updated_at: zod.string().datetime({}).describe("The timestamp when this event was last updated"),
      meeting_url: zod.string().describe("The URL that can be used to join the meeting (if available)"),
      name: zod.string().describe("The title/name of the calendar event"),
      raw: zod.record(zod.string(), zod.any()).describe("Custom data object"),
      recurring_event_id: zod.string().nullish().describe("For recurring events, the ID of the parent recurring event series (if applicable)"),
      start_time: zod.string().datetime({}).describe("The start time of the event in UTC timezone"),
      uuid: zod.string().uuid()
    });
    scheduleRecordEventResponse = zod.array(scheduleRecordEventResponseItem);
    unscheduleRecordEventParams = zod.object({
      uuid: zod.string().describe("The UUID identifier")
    });
    unscheduleRecordEventQueryParams = zod.object({
      all_occurrences: zod.boolean().nullish().describe("unschedule a bot from all occurences of a recurring event")
    });
    unscheduleRecordEventResponseItem = zod.object({
      attendees: zod.array(
        zod.object({
          email: zod.string().describe("The email address of the meeting attendee"),
          name: zod.string().nullish().describe(
            "The display name of the attendee if available from the calendar provider (Google, Microsoft)"
          )
        })
      ),
      bot_param: zod.object({
        bot_image: zod.string().nullish(),
        bot_name: zod.string(),
        deduplication_key: zod.string().nullish(),
        enter_message: zod.string().nullish(),
        extra: zod.record(zod.string(), zod.any()).describe("Custom data object"),
        noone_joined_timeout: zod.number().nullish(),
        recording_mode: zod.enum(["speaker_view"]).describe("Records the active speaker view").or(
          zod.enum(["gallery_view"]).describe("Records the gallery view showing multiple participants")
        ).or(zod.enum(["audio_only"]).describe("Records only the audio from the meeting")).describe("Recording mode for the bot").or(zod.null()).optional(),
        speech_to_text_api_key: zod.string().nullish(),
        speech_to_text_provider: zod.enum(["Gladia", "Runpod", "Default"]).or(zod.null()).optional(),
        streaming_audio_frequency: zod.enum(["16khz", "24khz"]).or(zod.null()).optional(),
        streaming_input: zod.string().nullish(),
        streaming_output: zod.string().nullish(),
        transcription_custom_parameters: zod.record(zod.string(), zod.any()).describe("Custom data object"),
        waiting_room_timeout: zod.number().nullish(),
        webhook_url: zod.string(),
        zoom_sdk_id: zod.string().nullish(),
        zoom_sdk_pwd: zod.string().nullish()
      }).or(zod.null()).optional().describe("Associated bot parameters if a bot is scheduled for this event"),
      calendar_uuid: zod.string().uuid(),
      deleted: zod.boolean().describe("Indicates whether this event has been deleted"),
      end_time: zod.string().datetime({}).describe("The end time of the event in UTC timezone"),
      google_id: zod.string().describe("The unique identifier of the event from the calendar provider (Google, Microsoft)"),
      is_organizer: zod.boolean().describe("Indicates whether the current user is the organizer of this event"),
      is_recurring: zod.boolean().describe("Indicates whether this event is part of a recurring series"),
      last_updated_at: zod.string().datetime({}).describe("The timestamp when this event was last updated"),
      meeting_url: zod.string().describe("The URL that can be used to join the meeting (if available)"),
      name: zod.string().describe("The title/name of the calendar event"),
      raw: zod.record(zod.string(), zod.any()).describe("Custom data object"),
      recurring_event_id: zod.string().nullish().describe("For recurring events, the ID of the parent recurring event series (if applicable)"),
      start_time: zod.string().datetime({}).describe("The start time of the event in UTC timezone"),
      uuid: zod.string().uuid()
    });
    unscheduleRecordEventResponse = zod.array(unscheduleRecordEventResponseItem);
    patchBotParams = zod.object({
      uuid: zod.string().describe("The UUID identifier")
    });
    patchBotQueryParams = zod.object({
      all_occurrences: zod.boolean().nullish().describe("schedule a bot to all occurences of a recurring event")
    });
    patchBotBodyBotImageDefault = null;
    patchBotBodyDeduplicationKeyDefault = null;
    patchBotBodyEnterMessageDefault = null;
    patchBotBodyExtraDefault = null;
    patchBotBodyNooneJoinedTimeoutDefault = null;
    patchBotBodySpeechToTextDefault = null;
    patchBotBodyStreamingAudioFrequencyDefault = null;
    patchBotBodyStreamingInputDefault = null;
    patchBotBodyStreamingOutputDefault = null;
    patchBotBodyTranscriptionCustomParametersDefault = null;
    patchBotBodyWaitingRoomTimeoutDefault = null;
    patchBotBodyZoomSdkIdDefault = null;
    patchBotBodyZoomSdkPwdDefault = null;
    patchBotBody = zod.object({
      bot_image: zod.string().nullish(),
      bot_name: zod.string().nullish(),
      deduplication_key: zod.string().nullish(),
      enter_message: zod.string().nullish(),
      extra: zod.any().optional(),
      noone_joined_timeout: zod.number().nullish(),
      recording_mode: zod.enum(["speaker_view"]).describe("Records the active speaker view").or(
        zod.enum(["gallery_view"]).describe("Records the gallery view showing multiple participants")
      ).or(zod.enum(["audio_only"]).describe("Records only the audio from the meeting")).describe("Recording mode for the bot").or(zod.null()).or(zod.null()).optional(),
      speech_to_text: zod.object({
        api_key: zod.string().nullish(),
        provider: zod.enum(["Gladia", "Runpod", "Default"])
      }).or(zod.enum(["Gladia", "Runpod", "Default"])).or(zod.null()).or(zod.null()).optional(),
      streaming_audio_frequency: zod.enum(["16khz", "24khz"]).or(zod.null()).or(zod.null()).optional(),
      streaming_input: zod.string().nullish(),
      streaming_output: zod.string().nullish(),
      transcription_custom_parameters: zod.any().optional(),
      waiting_room_timeout: zod.number().nullish(),
      webhook_url: zod.string().nullish(),
      zoom_sdk_id: zod.string().nullish(),
      zoom_sdk_pwd: zod.string().nullish()
    });
    patchBotResponseItem = zod.object({
      attendees: zod.array(
        zod.object({
          email: zod.string().describe("The email address of the meeting attendee"),
          name: zod.string().nullish().describe(
            "The display name of the attendee if available from the calendar provider (Google, Microsoft)"
          )
        })
      ),
      bot_param: zod.object({
        bot_image: zod.string().nullish(),
        bot_name: zod.string(),
        deduplication_key: zod.string().nullish(),
        enter_message: zod.string().nullish(),
        extra: zod.record(zod.string(), zod.any()).describe("Custom data object"),
        noone_joined_timeout: zod.number().nullish(),
        recording_mode: zod.enum(["speaker_view"]).describe("Records the active speaker view").or(
          zod.enum(["gallery_view"]).describe("Records the gallery view showing multiple participants")
        ).or(zod.enum(["audio_only"]).describe("Records only the audio from the meeting")).describe("Recording mode for the bot").or(zod.null()).optional(),
        speech_to_text_api_key: zod.string().nullish(),
        speech_to_text_provider: zod.enum(["Gladia", "Runpod", "Default"]).or(zod.null()).optional(),
        streaming_audio_frequency: zod.enum(["16khz", "24khz"]).or(zod.null()).optional(),
        streaming_input: zod.string().nullish(),
        streaming_output: zod.string().nullish(),
        transcription_custom_parameters: zod.record(zod.string(), zod.any()).describe("Custom data object"),
        waiting_room_timeout: zod.number().nullish(),
        webhook_url: zod.string(),
        zoom_sdk_id: zod.string().nullish(),
        zoom_sdk_pwd: zod.string().nullish()
      }).or(zod.null()).optional().describe("Associated bot parameters if a bot is scheduled for this event"),
      calendar_uuid: zod.string().uuid(),
      deleted: zod.boolean().describe("Indicates whether this event has been deleted"),
      end_time: zod.string().datetime({}).describe("The end time of the event in UTC timezone"),
      google_id: zod.string().describe("The unique identifier of the event from the calendar provider (Google, Microsoft)"),
      is_organizer: zod.boolean().describe("Indicates whether the current user is the organizer of this event"),
      is_recurring: zod.boolean().describe("Indicates whether this event is part of a recurring series"),
      last_updated_at: zod.string().datetime({}).describe("The timestamp when this event was last updated"),
      meeting_url: zod.string().describe("The URL that can be used to join the meeting (if available)"),
      name: zod.string().describe("The title/name of the calendar event"),
      raw: zod.record(zod.string(), zod.any()).describe("Custom data object"),
      recurring_event_id: zod.string().nullish().describe("For recurring events, the ID of the parent recurring event series (if applicable)"),
      start_time: zod.string().datetime({}).describe("The start time of the event in UTC timezone"),
      uuid: zod.string().uuid()
    });
    patchBotResponse = zod.array(patchBotResponseItem);
    listEventsQueryParams = zod.object({
      attendee_email: zod.string().nullish().describe(
        `If provided, filters events to include only those with this attendee's email address Example: "jane.smith@example.com"`
      ),
      calendar_id: zod.string().describe(
        "Calendar ID to filter events by This is required to specify which calendar's events to retrieve"
      ),
      cursor: zod.string().nullish().describe(
        "Optional cursor for pagination This value is included in the `next` field of the previous response"
      ),
      organizer_email: zod.string().nullish().describe(
        `If provided, filters events to include only those with this organizer's email address Example: "john.doe@example.com"`
      ),
      start_date_gte: zod.string().nullish().describe(
        'If provided, filters events to include only those with a start date greater than or equal to this timestamp Format: ISO-8601 string, e.g., "2023-01-01T00:00:00Z"'
      ),
      start_date_lte: zod.string().nullish().describe(
        'If provided, filters events to include only those with a start date less than or equal to this timestamp Format: ISO-8601 string, e.g., "2023-12-31T23:59:59Z"'
      ),
      status: zod.string().nullish().describe(
        'Filter events by meeting status Valid values: "upcoming" (default) returns events after current time, "past" returns previous events, "all" returns both'
      ),
      updated_at_gte: zod.string().nullish().describe(
        'If provided, fetches only events updated at or after this timestamp Format: ISO-8601 string, e.g., "2023-01-01T00:00:00Z"'
      )
    });
    listEventsResponse = zod.object({
      data: zod.array(
        zod.object({
          attendees: zod.array(
            zod.object({
              email: zod.string().describe("The email address of the meeting attendee"),
              name: zod.string().nullish().describe(
                "The display name of the attendee if available from the calendar provider (Google, Microsoft)"
              )
            })
          ),
          bot_param: zod.object({
            bot_image: zod.string().nullish(),
            bot_name: zod.string(),
            deduplication_key: zod.string().nullish(),
            enter_message: zod.string().nullish(),
            extra: zod.record(zod.string(), zod.any()).describe("Custom data object"),
            noone_joined_timeout: zod.number().nullish(),
            recording_mode: zod.enum(["speaker_view"]).describe("Records the active speaker view").or(
              zod.enum(["gallery_view"]).describe("Records the gallery view showing multiple participants")
            ).or(zod.enum(["audio_only"]).describe("Records only the audio from the meeting")).describe("Recording mode for the bot").or(zod.null()).optional(),
            speech_to_text_api_key: zod.string().nullish(),
            speech_to_text_provider: zod.enum(["Gladia", "Runpod", "Default"]).or(zod.null()).optional(),
            streaming_audio_frequency: zod.enum(["16khz", "24khz"]).or(zod.null()).optional(),
            streaming_input: zod.string().nullish(),
            streaming_output: zod.string().nullish(),
            transcription_custom_parameters: zod.record(zod.string(), zod.any()).describe("Custom data object"),
            waiting_room_timeout: zod.number().nullish(),
            webhook_url: zod.string(),
            zoom_sdk_id: zod.string().nullish(),
            zoom_sdk_pwd: zod.string().nullish()
          }).or(zod.null()).optional().describe("Associated bot parameters if a bot is scheduled for this event"),
          calendar_uuid: zod.string().uuid(),
          deleted: zod.boolean().describe("Indicates whether this event has been deleted"),
          end_time: zod.string().datetime({}).describe("The end time of the event in UTC timezone"),
          google_id: zod.string().describe(
            "The unique identifier of the event from the calendar provider (Google, Microsoft)"
          ),
          is_organizer: zod.boolean().describe("Indicates whether the current user is the organizer of this event"),
          is_recurring: zod.boolean().describe("Indicates whether this event is part of a recurring series"),
          last_updated_at: zod.string().datetime({}).describe("The timestamp when this event was last updated"),
          meeting_url: zod.string().describe("The URL that can be used to join the meeting (if available)"),
          name: zod.string().describe("The title/name of the calendar event"),
          raw: zod.record(zod.string(), zod.any()).describe("Custom data object"),
          recurring_event_id: zod.string().nullish().describe(
            "For recurring events, the ID of the parent recurring event series (if applicable)"
          ),
          start_time: zod.string().datetime({}).describe("The start time of the event in UTC timezone"),
          uuid: zod.string().uuid()
        })
      ).describe("Vector of calendar events matching the list criteria"),
      next: zod.string().nullish().describe(
        "Optional url for fetching the next page of results if there are more results to fetch. The limit of events returned is 100. When None, there are no more results to fetch."
      )
    });
  }
});

// src/generated/api/default/default.zod.ts
var default_zod_exports = {};
__export(default_zod_exports, {
  botsWithMetadataQueryLimitDefault: () => botsWithMetadataQueryLimitDefault,
  botsWithMetadataQueryParams: () => botsWithMetadataQueryParams,
  botsWithMetadataResponse: () => botsWithMetadataResponse,
  botsWithMetadataResponseLastUpdatedDefault: () => botsWithMetadataResponseLastUpdatedDefault,
  deleteDataParams: () => deleteDataParams,
  deleteDataResponse: () => deleteDataResponse,
  getMeetingDataQueryIncludeTranscriptsDefault: () => getMeetingDataQueryIncludeTranscriptsDefault,
  getMeetingDataQueryParams: () => getMeetingDataQueryParams,
  getMeetingDataResponse: () => getMeetingDataResponse,
  getScreenshotsParams: () => getScreenshotsParams,
  getScreenshotsResponse: () => getScreenshotsResponse,
  getScreenshotsResponseItem: () => getScreenshotsResponseItem,
  joinBody: () => joinBody,
  joinBodyAutomaticLeaveNooneJoinedTimeoutMin: () => joinBodyAutomaticLeaveNooneJoinedTimeoutMin,
  joinBodyAutomaticLeaveWaitingRoomTimeoutMin: () => joinBodyAutomaticLeaveWaitingRoomTimeoutMin,
  joinBodyStartTimeMin: () => joinBodyStartTimeMin,
  joinBodyTranscriptionCustomParametersDefault: () => joinBodyTranscriptionCustomParametersDefault,
  joinResponse: () => joinResponse,
  leaveParams: () => leaveParams,
  leaveResponse: () => leaveResponse,
  retranscribeBotBody: () => retranscribeBotBody
});
import { z as zod2 } from "zod";
var joinBodyAutomaticLeaveNooneJoinedTimeoutMin, joinBodyAutomaticLeaveWaitingRoomTimeoutMin, joinBodyStartTimeMin, joinBodyTranscriptionCustomParametersDefault, joinBody, joinResponse, leaveParams, leaveResponse, getMeetingDataQueryIncludeTranscriptsDefault, getMeetingDataQueryParams, getMeetingDataResponse, deleteDataParams, deleteDataResponse, botsWithMetadataQueryLimitDefault, botsWithMetadataQueryParams, botsWithMetadataResponseLastUpdatedDefault, botsWithMetadataResponse, retranscribeBotBody, getScreenshotsParams, getScreenshotsResponseItem, getScreenshotsResponse;
var init_default_zod = __esm({
  "src/generated/api/default/default.zod.ts"() {
    "use strict";
    joinBodyAutomaticLeaveNooneJoinedTimeoutMin = 0;
    joinBodyAutomaticLeaveWaitingRoomTimeoutMin = 0;
    joinBodyStartTimeMin = 0;
    joinBodyTranscriptionCustomParametersDefault = null;
    joinBody = zod2.object({
      automatic_leave: zod2.object({
        noone_joined_timeout: zod2.number().min(joinBodyAutomaticLeaveNooneJoinedTimeoutMin).nullish().describe(
          "The timeout in seconds for the bot to wait for participants to join before leaving the meeting, defaults to 600 seconds"
        ),
        waiting_room_timeout: zod2.number().min(joinBodyAutomaticLeaveWaitingRoomTimeoutMin).nullish().describe(
          "The timeout in seconds for the bot to wait in the waiting room before leaving the meeting, defaults to 600 seconds"
        )
      }).or(zod2.null()).optional().describe(
        "The bot will leave the meeting automatically after the timeout, defaults to 600 seconds."
      ),
      bot_image: zod2.string().url().nullish().describe("The image to use for the bot, must be a URL. Recommended ratio is 16:9."),
      bot_name: zod2.string(),
      deduplication_key: zod2.string().nullish().describe(
        "We prevent multiple bots with same API key joining a meeting within 5 mins, unless overridden by deduplication_key."
      ),
      entry_message: zod2.string().nullish().describe(
        "There are no entry messages on Microsoft Teams as guests outside of an organization do not have access to the chat."
      ),
      extra: zod2.record(zod2.string(), zod2.any()).optional().describe("Custom data object"),
      meeting_url: zod2.string(),
      recording_mode: zod2.enum(["speaker_view"]).describe("Records the active speaker view").or(
        zod2.enum(["gallery_view"]).describe("Records the gallery view showing multiple participants")
      ).or(zod2.enum(["audio_only"]).describe("Records only the audio from the meeting")).describe("Recording mode for the bot").or(zod2.null()).optional().describe("The recording mode for the bot, defaults to 'speaker_view'."),
      reserved: zod2.boolean().describe(
        "Whether or not the bot should come from the available pool of bots or be a dedicated bot. Reserved bots come in exactly 4 minutes after the request."
      ),
      speech_to_text: zod2.object({
        api_key: zod2.string().nullish(),
        provider: zod2.enum(["Gladia", "Runpod", "Default"])
      }).or(zod2.enum(["Gladia", "Runpod", "Default"])).or(zod2.null()).optional().describe("The default speech to text provider is Gladia."),
      start_time: zod2.number().min(joinBodyStartTimeMin).nullish().describe(
        "Unix timestamp (in milliseconds) for when the bot should join the meeting. The bot joins 4 minutes before the start time."
      ),
      streaming: zod2.object({
        audio_frequency: zod2.enum(["16khz", "24khz"]).or(zod2.null()).optional(),
        input: zod2.string().nullish(),
        output: zod2.string().nullish()
      }).or(zod2.null()).optional().describe(
        "WebSocket streams for 16 kHz audio. Input stream receives audio sent to the bot. Output stream receives audio from the bot."
      ),
      transcription_custom_parameters: zod2.any().optional().describe("For your own transcription parameters"),
      webhook_url: zod2.string().nullish().describe(
        "A webhook URL to send events to, overrides the webhook URL set in your account settings."
      ),
      zoom_sdk_id: zod2.string().nullish().describe("For the Own Zoom Credentials feature, we need your zoom sdk id."),
      zoom_sdk_pwd: zod2.string().nullish().describe("For the Own Zoom Credentials feature, we need your zoom sdk pwd.")
    });
    joinResponse = zod2.object({
      bot_id: zod2.string().uuid()
    });
    leaveParams = zod2.object({
      uuid: zod2.string().describe("The UUID identifier")
    });
    leaveResponse = zod2.object({
      ok: zod2.boolean()
    });
    getMeetingDataQueryIncludeTranscriptsDefault = true;
    getMeetingDataQueryParams = zod2.object({
      bot_id: zod2.string(),
      include_transcripts: zod2.boolean().default(getMeetingDataQueryIncludeTranscriptsDefault).describe(
        "Whether to include transcription data in the response. Defaults to true if not specified."
      )
    });
    getMeetingDataResponse = zod2.object({
      bot_data: zod2.object({
        bot: zod2.object({
          account_id: zod2.number(),
          bot_image: zod2.string().nullish(),
          bot_name: zod2.string(),
          bot_param_id: zod2.number(),
          created_at: zod2.string().datetime({}),
          deduplication_key: zod2.string().nullish(),
          diarization_fails: zod2.number().nullish(),
          diarization_v2: zod2.boolean(),
          ended_at: zod2.string().datetime({}).nullable(),
          enter_message: zod2.string().nullish(),
          errors: zod2.string().nullish(),
          event_id: zod2.number().nullish(),
          extra: zod2.record(zod2.string(), zod2.any()).describe("Custom data object"),
          id: zod2.number(),
          meeting_url: zod2.string(),
          mp4_s3_path: zod2.string(),
          noone_joined_timeout: zod2.number().nullish(),
          recording_mode: zod2.enum(["speaker_view"]).describe("Records the active speaker view").or(
            zod2.enum(["gallery_view"]).describe("Records the gallery view showing multiple participants")
          ).or(zod2.enum(["audio_only"]).describe("Records only the audio from the meeting")).describe("Recording mode for the bot").or(zod2.null()).optional(),
          reserved: zod2.boolean(),
          scheduled_bot_id: zod2.number().nullish(),
          session_id: zod2.string().nullish(),
          speech_to_text_api_key: zod2.string().nullish(),
          speech_to_text_provider: zod2.enum(["Gladia", "Runpod", "Default"]).or(zod2.null()).optional(),
          streaming_audio_frequency: zod2.enum(["16khz", "24khz"]).or(zod2.null()).optional(),
          streaming_input: zod2.string().nullish(),
          streaming_output: zod2.string().nullish(),
          transcription_custom_parameters: zod2.record(zod2.string(), zod2.any()).describe("Custom data object"),
          transcription_fails: zod2.number().nullish(),
          transcription_payloads: zod2.any().optional(),
          user_reported_error: zod2.any().optional(),
          uuid: zod2.string().uuid(),
          waiting_room_timeout: zod2.number().nullish(),
          webhook_url: zod2.string(),
          zoom_sdk_id: zod2.string().nullish(),
          zoom_sdk_pwd: zod2.string().nullish()
        }),
        transcripts: zod2.array(
          zod2.object({
            bot_id: zod2.number(),
            end_time: zod2.number().nullish(),
            id: zod2.number(),
            lang: zod2.string().nullish(),
            speaker: zod2.string(),
            start_time: zod2.number(),
            user_id: zod2.number().nullish(),
            words: zod2.array(
              zod2.object({
                bot_id: zod2.number(),
                end_time: zod2.number(),
                id: zod2.number(),
                start_time: zod2.number(),
                text: zod2.string(),
                user_id: zod2.number().nullish()
              })
            )
          })
        )
      }),
      duration: zod2.number().describe("Duration of the recording in seconds"),
      mp4: zod2.string().describe(
        "URL to access the recording MP4 file. Will be an empty string if the file doesn't exist in S3."
      )
    });
    deleteDataParams = zod2.object({
      uuid: zod2.string().describe("The UUID identifier")
    });
    deleteDataResponse = zod2.object({
      ok: zod2.boolean().describe("Whether the request was processed successfully"),
      status: zod2.enum(["deleted"]).describe("All data was successfully deleted").or(
        zod2.enum(["partiallyDeleted"]).describe("Some data was deleted, but other parts couldn't be removed")
      ).or(
        zod2.enum(["alreadyDeleted"]).describe("No data needed to be deleted as it was already removed")
      ).or(zod2.enum(["noDataFound"]).describe("No data was found for the specified bot"))
    });
    botsWithMetadataQueryLimitDefault = 10;
    botsWithMetadataQueryParams = zod2.object({
      bot_name: zod2.string().nullish().describe(
        `Filter bots by name containing this string.

Performs a case-insensitive partial match on the bot's name. Useful for finding bots with specific naming conventions or to locate a particular bot when you don't have its ID.

Example: "Sales" would match "Sales Meeting", "Quarterly Sales", etc.`
      ),
      created_after: zod2.string().nullish().describe(
        'Filter bots created after this date (ISO format).\n\nLimits results to bots created at or after the specified timestamp. Used for time-based filtering to find recent additions.\n\nFormat: ISO-8601 date-time string (YYYY-MM-DDThh:mm:ss) Example: "2023-05-01T00:00:00"'
      ),
      created_before: zod2.string().nullish().describe(
        'Filter bots created before this date (ISO format).\n\nLimits results to bots created at or before the specified timestamp. Used for time-based filtering to exclude recent additions.\n\nFormat: ISO-8601 date-time string (YYYY-MM-DDThh:mm:ss) Example: "2023-05-31T23:59:59"'
      ),
      cursor: zod2.string().nullish().describe(
        "Cursor for pagination, obtained from previous response.\n\nUsed for retrieving the next set of results after a previous call. The cursor value is returned in the `nextCursor` field of responses that have additional results available.\n\nFormat: Base64-encoded string containing pagination metadata"
      ),
      ended_after: zod2.string().nullish().describe(
        'Filter bots ended after this date (ISO format).\n\nLimits results to bots that ended at or after the specified timestamp. Useful for finding completed meetings within a specific time period.\n\nFormat: ISO-8601 date-time string (YYYY-MM-DDThh:mm:ss) Example: "2023-05-01T00:00:00"'
      ),
      filter_by_extra: zod2.string().nullish().describe(
        'Filter bots by matching values in the extra JSON payload.\n\nThis parameter performs in-memory filtering on the `extra` JSON field, similar to a SQL WHERE clause. It reduces the result set to only include bots that match all specified conditions.\n\nFormat specifications: - Single condition: "field:value" - Multiple conditions: "field1:value1,field2:value2"\n\nExamples: - "customer_id:12345" - Only bots with this customer ID - "status:active,project:sales" - Only active bots from sales projects\n\nNotes: - All conditions must match for a bot to be included - Values are matched exactly (case-sensitive) - Bots without the specified field are excluded'
      ),
      limit: zod2.number().default(botsWithMetadataQueryLimitDefault).describe(
        "Maximum number of bots to return in a single request.\n\nLimits the number of results returned in a single API call. This parameter helps control response size and page length.\n\nDefault: 10 Minimum: 1 Maximum: 50"
      ),
      meeting_url: zod2.string().nullish().describe(
        `Filter bots by meeting URL containing this string.

Performs a case-insensitive partial match on the bot's meeting URL. Use this to find bots associated with specific meeting platforms or particular meeting IDs.

Example: "zoom.us" would match all Zoom meetings`
      ),
      sort_by_extra: zod2.string().nullish().describe(
        'Sort the results by a field in the extra JSON payload.\n\nThis parameter performs in-memory sorting on the `extra` JSON field, similar to a SQL ORDER BY clause. It changes the order of results but not which results are included.\n\nFormat specifications: - Default (ascending): "field" - Explicit direction: "field:asc" or "field:desc"\n\nExamples: - "customer_id" - Sort by customer_id (ascending) - "priority:desc" - Sort by priority (descending)\n\nNotes: - Applied after all filtering - String comparison is used for sorting - Bots with the field come before bots without it - Can be combined with filter_by_extra'
      ),
      speaker_name: zod2.string().nullish().describe(
        'NOTE: this is a preview feature and not yet available\n\nFilter bots by speaker name containing this string.\n\nPerforms a case-insensitive partial match on the speakers in the meeting. Useful for finding meetings that included a specific person.\n\nExample: "John" would match meetings with speakers like "John Smith" or "John Doe"'
      )
    });
    botsWithMetadataResponseLastUpdatedDefault = "2025-01-01T00:00:00.000000000+00:00";
    botsWithMetadataResponse = zod2.object({
      bots: zod2.array(
        zod2.object({
          access_count: zod2.number().nullish().describe("Number of times this bot data has been accessed (if tracked)"),
          bot_name: zod2.string().describe("Name of the bot"),
          created_at: zod2.string().describe("Creation timestamp of the bot in ISO-8601 format"),
          duration: zod2.number().nullish().describe("Duration of the bot session in seconds (if completed)"),
          ended_at: zod2.string().nullish().describe("End time of the bot session (if completed) in ISO-8601 format"),
          extra: zod2.record(zod2.string(), zod2.any()).describe("Custom data object"),
          id: zod2.number().describe(
            "Unique identifier of the bot (legacy field)\n\nThis field is maintained for backwards compatibility. It is serialized as a UUID string to match the old API format. New clients should use the uuid field instead."
          ),
          last_accessed_at: zod2.string().nullish().describe("Last time this bot data was accessed (if available)"),
          meeting_url: zod2.string().describe("URL of the meeting the bot joined"),
          session_id: zod2.string().nullish().describe("Session ID if the bot is active"),
          speakers: zod2.array(zod2.string()).describe("List of unique speaker names from the bot's transcripts"),
          uuid: zod2.string().uuid().describe(
            "Unique identifier of the bot (new field)\n\nThis is the preferred field to use for bot identification. The id field is maintained for backwards compatibility."
          )
        }).describe("Entry for a recent bot in the list response")
      ).describe(
        'List of recent bots with their metadata\n\nThis field is serialized as both "bots" and "recent_bots" for backwards compatibility. New clients should use the "bots" field name.'
      ),
      last_updated: zod2.string().datetime({}).default(botsWithMetadataResponseLastUpdatedDefault).describe(
        "Timestamp of when this data was generated (in ISO-8601 format)\n\nThis field is maintained for backwards compatibility. It is automatically set to the current time when the response is created."
      ),
      next_cursor: zod2.string().nullish().describe("Optional cursor for pagination")
    }).describe("Response for listing recent bots");
    retranscribeBotBody = zod2.object({
      bot_uuid: zod2.string(),
      speech_to_text: zod2.object({
        api_key: zod2.string().nullish(),
        provider: zod2.enum(["Gladia", "Runpod", "Default"])
      }).or(zod2.enum(["Gladia", "Runpod", "Default"])).or(zod2.null()).optional(),
      webhook_url: zod2.string().nullish()
    });
    getScreenshotsParams = zod2.object({
      uuid: zod2.string().describe("The UUID identifier")
    });
    getScreenshotsResponseItem = zod2.object({
      date: zod2.string(),
      url: zod2.string()
    }).describe("Schema-compatible wrapper for the Screenshot struct");
    getScreenshotsResponse = zod2.array(getScreenshotsResponseItem);
  }
});

// src/generated/api/default/default.ts
var default_exports = {};
__export(default_exports, {
  botsWithMetadata: () => botsWithMetadata,
  deleteData: () => deleteData,
  getMeetingData: () => getMeetingData,
  getScreenshots: () => getScreenshots,
  join: () => join,
  leave: () => leave,
  retranscribeBot: () => retranscribeBot
});
import axios from "axios";
var join, leave, getMeetingData, deleteData, botsWithMetadata, retranscribeBot, getScreenshots;
var init_default = __esm({
  "src/generated/api/default/default.ts"() {
    "use strict";
    join = (joinRequest, options) => {
      return axios.post("/bots/", joinRequest, options);
    };
    leave = (uuid, options) => {
      return axios.delete(`/bots/${uuid}`, options);
    };
    getMeetingData = (params, options) => {
      return axios.get("/bots/meeting_data", {
        ...options,
        params: { ...params, ...options?.params }
      });
    };
    deleteData = (uuid, options) => {
      return axios.post(`/bots/${uuid}/delete_data`, void 0, options);
    };
    botsWithMetadata = (params, options) => {
      return axios.get("/bots/bots_with_metadata", {
        ...options,
        params: { ...params, ...options?.params }
      });
    };
    retranscribeBot = (retranscribeBody, options) => {
      return axios.post("/bots/retranscribe", retranscribeBody, options);
    };
    getScreenshots = (uuid, options) => {
      return axios.get(`/bots/${uuid}/screenshots`, options);
    };
  }
});

// src/generated/api/calendars/calendars.ts
var calendars_exports = {};
__export(calendars_exports, {
  createCalendar: () => createCalendar,
  deleteCalendar: () => deleteCalendar,
  getCalendar: () => getCalendar,
  getEvent: () => getEvent,
  listCalendars: () => listCalendars,
  listEvents: () => listEvents,
  listRawCalendars: () => listRawCalendars,
  patchBot: () => patchBot,
  resyncAll: () => resyncAll,
  scheduleRecordEvent: () => scheduleRecordEvent,
  unscheduleRecordEvent: () => unscheduleRecordEvent,
  updateCalendar: () => updateCalendar
});
import axios2 from "axios";
var resyncAll, listRawCalendars, listCalendars, createCalendar, getCalendar, deleteCalendar, updateCalendar, getEvent, scheduleRecordEvent, unscheduleRecordEvent, patchBot, listEvents;
var init_calendars = __esm({
  "src/generated/api/calendars/calendars.ts"() {
    "use strict";
    resyncAll = (options) => {
      return axios2.post("/internal/calendar/resync_all", void 0, options);
    };
    listRawCalendars = (li