// AUTO-GENERATED by scripts/generate.ts from .generated-specs. Do not edit.
import * as S from "@distilled.cloud/core/schema";
import * as API from "@distilled.cloud/core/api";
import * as T from "../traits.ts";
import {
  CloudflareProtocol,
  type CloudflareOpError,
  type CloudflareOpContext,
} from "../protocol.ts";
import { CloudflareError, CloudflareRateLimited } from "../errors.ts";
import * as Retry from "../retry.ts";

export type { CloudflareOpError, CloudflareOpContext };

/** Fallback camelCase→wire mapping for opaque content (mined from the distilled SDK). */
const KEY_DICTIONARY: Record<string, string | ReadonlyArray<string>> = {
  acceptStageRequests: "accept_stage_requests",
  acceptWaitingRequests: "accept_waiting_requests",
  accessKey: "access_key",
  aiConfig: "ai_config",
  allowMultipleRecordings: "allow_multiple_recordings",
  associatedId: "associated_id",
  audioConfig: "audio_config",
  audioDownloadUrl: "audio_download_url",
  authMethod: "auth_method",
  borderRadius: "border_radius",
  borderWidth: "border_width",
  breakoutRooms: "breakout_rooms",
  canAcceptProductionRequests: "can_accept_production_requests",
  canAlterConnectedMeetings: "can_alter_connected_meetings",
  canChangeParticipantPermissions: "can_change_participant_permissions",
  canClose: "can_close",
  canCreate: "can_create",
  canEditConfig: "can_edit_config",
  canEditDisplayName: "can_edit_display_name",
  canLivestream: "can_livestream",
  canProduce: "can_produce",
  canReceive: "can_receive",
  canRecord: "can_record",
  canSend: "can_send",
  canSpotlight: "can_spotlight",
  canStart: "can_start",
  canSwitchConnectedMeetings: "can_switch_connected_meetings",
  canSwitchToParentMeeting: "can_switch_to_parent_meeting",
  canView: "can_view",
  canVote: "can_vote",
  chatDownloadUrl: "chat_download_url",
  chatDownloadUrlExpiry: "chat_download_url_expiry",
  configDiff: "config_diff",
  connectedMeetings: "connected_meetings",
  createdAt: "created_at",
  createdBy: "created_by",
  customParticipantId: "custom_participant_id",
  customParticipantIds: "custom_participant_ids",
  dayStats: "day_stats",
  designTokens: "design_tokens",
  disableParticipantAudio: "disable_participant_audio",
  disableParticipantScreensharing: "disable_participant_screensharing",
  disableParticipantVideo: "disable_participant_video",
  displayName: "display_name",
  downloadUrl: "download_url",
  downloadUrlExpiry: "download_url_expiry",
  enableHighBitrate: "enable_high_bitrate",
  enableStereo: "enable_stereo",
  endOffset: "end_offset",
  endedAt: "ended_at",
  errMessage: "err_message",
  exportFile: "export_file",
  fileNamePrefix: "file_name_prefix",
  fileSize: "file_size",
  fontFamily: "font_family",
  frameRate: "frame_rate",
  googleFont: "google_font",
  hiddenParticipant: "hidden_participant",
  hideVotes: "hide_votes",
  ingestSeconds: "ingest_seconds",
  ingestServer: "ingest_server",
  interactiveConfig: "interactive_config",
  invokedTime: "invoked_time",
  isRecorder: "is_recorder",
  joinedAt: "joined_at",
  kickParticipant: "kick_participant",
  kickedParticipantsCount: "kicked_participants_count",
  leftAt: "left_at",
  liveParticipants: "live_participants",
  liveStreamOnStart: "live_stream_on_start",
  liveStreamingConfig: "live_streaming_config",
  livestreamId: "livestream_id",
  livestreamViewerQualities: "livestream_viewer_qualities",
  maxConcurrentParticipants: "max_concurrent_participants",
  maxScreenshareCount: "max_screenshare_count",
  maxSeconds: "max_seconds",
  maxVideoStreams: "max_video_streams",
  meetingDisplayName: "meeting_display_name",
  meetingId: "meeting_id",
  minutesConsumed: "minutes_consumed",
  organizationId: "organization_id",
  outputFileName: "output_file_name",
  participantIds: "participant_ids",
  peerEvents: "peer_events",
  peerReport: "peer_report",
  persistChat: "persist_chat",
  pinParticipant: "pin_participant",
  playbackUrl: "playback_url",
  presetId: "preset_id",
  presetName: "preset_name",
  privateKey: "private_key",
  profanityFilter: "profanity_filter",
  realtimekitBucketConfig: "realtimekit_bucket_config",
  recordOnStart: "record_on_start",
  recorderType: "recorder_type",
  recordingConfig: "recording_config",
  recordingCount: "recording_count",
  recordingDuration: "recording_duration",
  recordingMinutesConsumed: "recording_minutes_consumed",
  recordingStats: "recording_stats",
  rtmpOutConfig: "rtmp_out_config",
  rtmpUrl: "rtmp_url",
  sessionId: "session_id",
  sessionKeepAliveTimeInSecs: "session_keep_alive_time_in_secs",
  sessionStats: "session_stats",
  sessionsCount: "sessions_count",
  sessionsMinutesConsumed: "sessions_minutes_consumed",
  showParticipantList: "show_participant_list",
  spacingBase: "spacing_base",
  stageAccess: "stage_access",
  stageEnabled: "stage_enabled",
  startOffset: "start_offset",
  startReason: "start_reason",
  startedAt: "started_at",
  startedTime: "started_time",
  stopReason: "stop_reason",
  stoppedTime: "stopped_time",
  storageConfig: "storage_config",
  streamKey: "stream_key",
  summarizeOnEnd: "summarize_on_end",
  summaryType: "summary_type",
  textFormat: "text_format",
  textOnBrand: "text_on_brand",
  totalCount: "total_count",
  totalIngestSeconds: "total_ingest_seconds",
  totalRecordingMinutes: "total_recording_minutes",
  totalRecordings: "total_recordings",
  totalSessionMinutes: "total_session_minutes",
  totalSessions: "total_sessions",
  totalViewerSeconds: "total_viewer_seconds",
  transcribeOnEnd: "transcribe_on_end",
  transcriptDownloadUrl: "transcript_download_url",
  transcriptDownloadUrlExpiry: "transcript_download_url_expiry",
  transcriptionEnabled: "transcription_enabled",
  updatedAt: "updated_at",
  userId: "user_id",
  userIds: "user_ids",
  videoBg: "video_bg",
  videoConfig: "video_config",
  viewType: "view_type",
  viewerSeconds: "viewer_seconds",
  waitingRoomType: "waiting_room_type",
  wordLimit: "word_limit",
};

export class Forbidden
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<Forbidden>()("Forbidden", {
      code: S.Number,
      message: S.String,
    }),
    [{ status: 403 }],
  ) {}

export class RealtimeKitPresetExists
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<RealtimeKitPresetExists>()(
      "RealtimeKitPresetExists",
      {
        code: S.Number,
        message: S.String,
      },
    ),
    [{ status: 409 }],
  ) {}

export class RealtimeKitPresetNotFound
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<RealtimeKitPresetNotFound>()(
      "RealtimeKitPresetNotFound",
      {
        code: S.Number,
        message: S.String,
      },
    ),
    [{ status: 404 }],
  ) {}

export class RealtimeKitWebhookExists
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<RealtimeKitWebhookExists>()(
      "RealtimeKitWebhookExists",
      {
        code: S.Number,
        message: S.String,
      },
    ),
    [{ status: 409 }],
  ) {}

export class RealtimeKitWebhookNotFound
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<RealtimeKitWebhookNotFound>()(
      "RealtimeKitWebhookNotFound",
      {
        code: S.Number,
        message: S.String,
      },
    ),
    [{ status: 404 }],
  ) {}

export interface AddParticipantMeetingRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  meetingId: string;
  /** A unique participant ID. You must specify a unique ID for the participant, for example, UUID, email address, and so on. */
  customParticipantId: string;
  /** Name of the preset to apply to this participant. */
  presetName: string;
  /** (Optional) Name of the participant. */
  name?: string;
  /** (Optional) A URL to a picture to be used for the participant. */
  picture?: string;
}
export const AddParticipantMeetingRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    appId: S.String.pipe(T.Label("app_id")),
    meetingId: S.String.pipe(T.Label("meeting_id")),
    customParticipantId: S.String.pipe(T.Body("custom_participant_id")),
    presetName: S.String.pipe(T.Body("preset_name")),
    name: S.optional(S.String),
    picture: S.optional(S.String),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/realtime/kit/{app_id}/meetings/{meeting_id}/participants",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "AddParticipantMeetingRequest",
}) as any as S.Schema<AddParticipantMeetingRequest>;

export interface MeetingsAddParticipantResponseData {
  /** ID of the participant. */
  id: string;
  /** The participant's auth token that can be used for joining a meeting from the client side. */
  token: string;
  /** When this object was created. The time is returned in ISO format. */
  createdAt: string;
  /** A unique participant ID generated by the client. */
  customParticipantId: string;
  /** Preset applied to the participant. */
  presetName: string;
  /** When this object was updated. The time is returned in ISO format. */
  updatedAt: string;
  /** Name of the participant. */
  name?: string | null;
  /** URL to a picture of the participant. */
  picture?: string | null;
}
export const MeetingsAddParticipantResponseData = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    token: S.String,
    createdAt: S.String.pipe(T.Body("created_at")),
    customParticipantId: S.String.pipe(T.Body("custom_participant_id")),
    presetName: S.String.pipe(T.Body("preset_name")),
    updatedAt: S.String.pipe(T.Body("updated_at")),
    name: S.optional(S.NullOr(S.String)),
    picture: S.optional(S.NullOr(S.String)),
  }),
).annotate({
  identifier: "MeetingsAddParticipantResponseData",
}) as any as S.Schema<MeetingsAddParticipantResponseData>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface AddParticipantMeetingResponse {
  /** Represents a participant. */
  data?: MeetingsAddParticipantResponseData | null;
}
export const AddParticipantMeetingResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    data: S.optional(S.NullOr(MeetingsAddParticipantResponseData)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "AddParticipantMeetingResponse",
}) as any as S.Schema<AddParticipantMeetingResponse>;

export interface CreateIndependentLivestreamLivestreamRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  /** Name of the livestream */
  name?: string;
}
export const CreateIndependentLivestreamLivestreamRequest =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      accountId: S.String.pipe(T.Label("account_id")),
      appId: S.String.pipe(T.Label("app_id")),
      name: S.optional(S.String),
    })
      .pipe(
        T.Http({
          method: "POST",
          uri: "/accounts/{account_id}/realtime/kit/{app_id}/livestreams",
          code: 200,
        }),
      )
      .pipe(T.KeyDictionary(KEY_DICTIONARY)),
  ).annotate({
    identifier: "CreateIndependentLivestreamLivestreamRequest",
  }) as any as S.Schema<CreateIndependentLivestreamLivestreamRequest>;

export type LivestreamsCreateIndependentLivestreamResponseDataStatus =
  | "LIVE"
  | "IDLE"
  | "ERRORED"
  | "INVOKED";
export const LivestreamsCreateIndependentLivestreamResponseDataStatus =
  /*@__PURE__*/ S.String;

export interface LivestreamsCreateIndependentLivestreamResponseData {
  /** The livestream ID. */
  id?: string | null;
  /** Specifies if the livestream was disabled. */
  disabled?: boolean | null;
  /** The server URL to which the RTMP encoder should send the video and audio data. */
  ingestServer?: string | null;
  meetingId?: string | null;
  name?: string | null;
  /** The web address that viewers can use to watch the livestream. */
  playbackUrl?: string | null;
  status?: LivestreamsCreateIndependentLivestreamResponseDataStatus | null;
  /** Unique key for accessing each livestream. */
  streamKey?: string | null;
}
export const LivestreamsCreateIndependentLivestreamResponseData =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.optional(S.NullOr(S.String)),
      disabled: S.optional(S.NullOr(S.Boolean)),
      ingestServer: S.optional(
        S.NullOr(S.String).pipe(T.Body("ingest_server")),
      ),
      meetingId: S.optional(S.NullOr(S.String).pipe(T.Body("meeting_id"))),
      name: S.optional(S.NullOr(S.String)),
      playbackUrl: S.optional(S.NullOr(S.String).pipe(T.Body("playback_url"))),
      status: S.optional(
        S.NullOr(LivestreamsCreateIndependentLivestreamResponseDataStatus),
      ),
      streamKey: S.optional(S.NullOr(S.String).pipe(T.Body("stream_key"))),
    }),
  ).annotate({
    identifier: "LivestreamsCreateIndependentLivestreamResponseData",
  }) as any as S.Schema<LivestreamsCreateIndependentLivestreamResponseData>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface CreateIndependentLivestreamLivestreamResponse {
  data?: LivestreamsCreateIndependentLivestreamResponseData | null;
}
export const CreateIndependentLivestreamLivestreamResponse =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      data: S.optional(
        S.NullOr(LivestreamsCreateIndependentLivestreamResponseData),
      ),
    }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
  ).annotate({
    identifier: "CreateIndependentLivestreamLivestreamResponse",
  }) as any as S.Schema<CreateIndependentLivestreamLivestreamResponse>;

export type MeetingsCreateRequestAiConfigSummarizationSummaryType =
  | "general"
  | "team_meeting"
  | "sales_call"
  | "client_check_in"
  | "interview"
  | "daily_standup"
  | "one_on_one_meeting"
  | "lecture"
  | "code_review";
export const MeetingsCreateRequestAiConfigSummarizationSummaryType =
  /*@__PURE__*/ S.String;

export type MeetingsCreateRequestAiConfigSummarizationTextFormat =
  | "plain_text"
  | "markdown";
export const MeetingsCreateRequestAiConfigSummarizationTextFormat =
  /*@__PURE__*/ S.String;

export interface MeetingsCreateRequestAiConfigSummarization {
  /** Defines the style of the summary, such as general, team meeting, or sales call. */
  summaryType?:
    | MeetingsCreateRequestAiConfigSummarizationSummaryType
    | (string & {});
  /** Determines the text format of the summary, such as plain text or markdown. */
  textFormat?:
    | MeetingsCreateRequestAiConfigSummarizationTextFormat
    | (string & {});
  /** Sets the maximum number of words in the meeting summary. */
  wordLimit?: number;
}
export const MeetingsCreateRequestAiConfigSummarization =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      summaryType: S.optional(
        MeetingsCreateRequestAiConfigSummarizationSummaryType.pipe(
          T.Body("summary_type"),
        ),
      ),
      textFormat: S.optional(
        MeetingsCreateRequestAiConfigSummarizationTextFormat.pipe(
          T.Body("text_format"),
        ),
      ),
      wordLimit: S.optional(S.Number.pipe(T.Body("word_limit"))),
    }),
  ).annotate({
    identifier: "MeetingsCreateRequestAiConfigSummarization",
  }) as any as S.Schema<MeetingsCreateRequestAiConfigSummarization>;

export type MeetingsCreateRequestAiConfigTranscriptionKeywordsList =
  Array<string>;
export const MeetingsCreateRequestAiConfigTranscriptionKeywordsList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<MeetingsCreateRequestAiConfigTranscriptionKeywordsList>;

export type MeetingsCreateRequestAiConfigTranscriptionLanguage =
  | "en-US"
  | "en-IN"
  | "de"
  | "hi"
  | "sv"
  | "ru"
  | "pl"
  | "el"
  | "fr"
  | "nl";
export const MeetingsCreateRequestAiConfigTranscriptionLanguage =
  /*@__PURE__*/ S.String;

export interface MeetingsCreateRequestAiConfigTranscription {
  /** Adds specific terms to improve accurate detection during transcription. */
  keywords?: MeetingsCreateRequestAiConfigTranscriptionKeywordsList;
  /** Specifies the language code for transcription to ensure accurate results. */
  language?: MeetingsCreateRequestAiConfigTranscriptionLanguage | (string & {});
  /** Control the inclusion of offensive language in transcriptions. */
  profanityFilter?: boolean;
}
export const MeetingsCreateRequestAiConfigTranscription =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      keywords: S.optional(
        MeetingsCreateRequestAiConfigTranscriptionKeywordsList,
      ),
      language: S.optional(MeetingsCreateRequestAiConfigTranscriptionLanguage),
      profanityFilter: S.optional(S.Boolean.pipe(T.Body("profanity_filter"))),
    }),
  ).annotate({
    identifier: "MeetingsCreateRequestAiConfigTranscription",
  }) as any as S.Schema<MeetingsCreateRequestAiConfigTranscription>;

export interface MeetingsCreateRequestAiConfig {
  /** Summary Config */
  summarization?: MeetingsCreateRequestAiConfigSummarization;
  /** Transcription Configurations */
  transcription?: MeetingsCreateRequestAiConfigTranscription;
}
export const MeetingsCreateRequestAiConfig = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    summarization: S.optional(MeetingsCreateRequestAiConfigSummarization),
    transcription: S.optional(MeetingsCreateRequestAiConfigTranscription),
  }),
).annotate({
  identifier: "MeetingsCreateRequestAiConfig",
}) as any as S.Schema<MeetingsCreateRequestAiConfig>;

export type MeetingsCreateRequestRecordingConfigAudioConfigChannel =
  | "mono"
  | "stereo";
export const MeetingsCreateRequestRecordingConfigAudioConfigChannel =
  /*@__PURE__*/ S.String;

export type MeetingsCreateRequestRecordingConfigAudioConfigCodec =
  | "MP3"
  | "AAC";
export const MeetingsCreateRequestRecordingConfigAudioConfigCodec =
  /*@__PURE__*/ S.String;

export interface MeetingsCreateRequestRecordingConfigAudioConfig {
  /** Audio signal pathway within an audio file that carries a specific sound source. */
  channel?:
    | MeetingsCreateRequestRecordingConfigAudioConfigChannel
    | (string & {});
  /** Codec using which the recording will be encoded. If VP8/VP9 is selected for videoConfig, changing audioConfig is not allowed. In this case, the codec in the audioConfig is automatically set to vorbis. */
  codec?: MeetingsCreateRequestRecordingConfigAudioConfigCodec | (string & {});
  /** Controls whether to export audio file seperately */
  exportFile?: boolean;
}
export const MeetingsCreateRequestRecordingConfigAudioConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      channel: S.optional(
        MeetingsCreateRequestRecordingConfigAudioConfigChannel,
      ),
      codec: S.optional(MeetingsCreateRequestRecordingConfigAudioConfigCodec),
      exportFile: S.optional(S.Boolean.pipe(T.Body("export_file"))),
    }),
  ).annotate({
    identifier: "MeetingsCreateRequestRecordingConfigAudioConfig",
  }) as any as S.Schema<MeetingsCreateRequestRecordingConfigAudioConfig>;

export interface MeetingsCreateRequestRecordingConfigLiveStreamingConfig {
  /** RTMP URL to stream to */
  rtmpUrl?: string;
}
export const MeetingsCreateRequestRecordingConfigLiveStreamingConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      rtmpUrl: S.optional(S.String.pipe(T.Body("rtmp_url"))),
    }),
  ).annotate({
    identifier: "MeetingsCreateRequestRecordingConfigLiveStreamingConfig",
  }) as any as S.Schema<MeetingsCreateRequestRecordingConfigLiveStreamingConfig>;

export interface MeetingsCreateRequestRecordingConfigRealtimekitBucketConfig {
  /** Controls whether recordings are uploaded to RealtimeKit's bucket. If set to false, `download_url`, `audio_download_url`, `download_url_expiry` won't be generated for a recording. */
  enabled: boolean;
}
export const MeetingsCreateRequestRecordingConfigRealtimekitBucketConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      enabled: S.Boolean,
    }),
  ).annotate({
    identifier: "MeetingsCreateRequestRecordingConfigRealtimekitBucketConfig",
  }) as any as S.Schema<MeetingsCreateRequestRecordingConfigRealtimekitBucketConfig>;

export type MeetingsCreateRequestRecordingConfigStorageConfigType =
  | "aws"
  | "azure"
  | "digitalocean"
  | "gcs"
  | "sftp";
export const MeetingsCreateRequestRecordingConfigStorageConfigType =
  /*@__PURE__*/ S.String;

export type MeetingsCreateRequestRecordingConfigStorageConfigAuthMethod =
  | "KEY"
  | "PASSWORD";
export const MeetingsCreateRequestRecordingConfigStorageConfigAuthMethod =
  /*@__PURE__*/ S.String;

export interface MeetingsCreateRequestRecordingConfigStorageConfig {
  /** Type of storage media. */
  type: MeetingsCreateRequestRecordingConfigStorageConfigType | (string & {});
  /** Access key of the storage medium. Access key is not required for the `gcs` storage media type. */
  accessKey?: string;
  /** Authentication method used for "sftp" type storage medium */
  authMethod?:
    | MeetingsCreateRequestRecordingConfigStorageConfigAuthMethod
    | (string & {});
  /** Name of the storage medium's bucket. */
  bucket?: string;
  /** SSH destination server host for SFTP type storage medium */
  host?: string;
  /** SSH destination server password for SFTP type storage medium when auth_method is "PASSWORD". If auth_method is "KEY", this specifies the password for the ssh private key. */
  password?: string;
  /** Path relative to the bucket root at which the recording will be placed. */
  path?: string;
  /** SSH destination server port for SFTP type storage medium */
  port?: number;
  /** Private key used to login to destination SSH server for SFTP type storage medium, when auth_method used is "KEY" */
  privateKey?: string;
  /** Region of the storage medium. */
  region?: string;
  /** Secret key of the storage medium. Similar to `access_key`, it is only writeable by clients, not readable. */
  secret?: string;
  /** SSH destination server username for SFTP type storage medium */
  username?: string;
}
export const MeetingsCreateRequestRecordingConfigStorageConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: MeetingsCreateRequestRecordingConfigStorageConfigType,
      accessKey: S.optional(S.String.pipe(T.Body("access_key"))),
      authMethod: S.optional(
        MeetingsCreateRequestRecordingConfigStorageConfigAuthMethod.pipe(
          T.Body("auth_method"),
        ),
      ),
      bucket: S.optional(S.String),
      host: S.optional(S.String),
      password: S.optional(S.String),
      path: S.optional(S.String),
      port: S.optional(S.Number),
      privateKey: S.optional(S.String.pipe(T.Body("private_key"))),
      region: S.optional(S.String),
      secret: S.optional(S.String),
      username: S.optional(S.String),
    }),
  ).annotate({
    identifier: "MeetingsCreateRequestRecordingConfigStorageConfig",
  }) as any as S.Schema<MeetingsCreateRequestRecordingConfigStorageConfig>;

export type MeetingsCreateRequestRecordingConfigVideoConfigCodec =
  | "H264"
  | "VP8";
export const MeetingsCreateRequestRecordingConfigVideoConfigCodec =
  /*@__PURE__*/ S.String;

export type MeetingsCreateRequestRecordingConfigVideoConfigWatermarkPosition =
  | "left top"
  | "right top"
  | "left bottom"
  | "right bottom";
export const MeetingsCreateRequestRecordingConfigVideoConfigWatermarkPosition =
  /*@__PURE__*/ S.String;

export interface MeetingsCreateRequestRecordingConfigVideoConfigWatermarkSize {
  /** Height of the watermark in px */
  height?: number;
  /** Width of the watermark in px */
  width?: number;
}
export const MeetingsCreateRequestRecordingConfigVideoConfigWatermarkSize =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      height: S.optional(S.Number),
      width: S.optional(S.Number),
    }),
  ).annotate({
    identifier: "MeetingsCreateRequestRecordingConfigVideoConfigWatermarkSize",
  }) as any as S.Schema<MeetingsCreateRequestRecordingConfigVideoConfigWatermarkSize>;

export interface MeetingsCreateRequestRecordingConfigVideoConfigWatermark {
  /** Position of the watermark */
  position?:
    | MeetingsCreateRequestRecordingConfigVideoConfigWatermarkPosition
    | (string & {});
  /** Size of the watermark */
  size?: MeetingsCreateRequestRecordingConfigVideoConfigWatermarkSize;
  /** URL of the watermark image */
  url?: string;
}
export const MeetingsCreateRequestRecordingConfigVideoConfigWatermark =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      position: S.optional(
        MeetingsCreateRequestRecordingConfigVideoConfigWatermarkPosition,
      ),
      size: S.optional(
        MeetingsCreateRequestRecordingConfigVideoConfigWatermarkSize,
      ),
      url: S.optional(S.String),
    }),
  ).annotate({
    identifier: "MeetingsCreateRequestRecordingConfigVideoConfigWatermark",
  }) as any as S.Schema<MeetingsCreateRequestRecordingConfigVideoConfigWatermark>;

export interface MeetingsCreateRequestRecordingConfigVideoConfig {
  /** Codec using which the recording will be encoded. */
  codec?: MeetingsCreateRequestRecordingConfigVideoConfigCodec | (string & {});
  /** Controls whether to export video file seperately */
  exportFile?: boolean;
  /** Height of the recording video in pixels */
  height?: number;
  /** Watermark to be added to the recording */
  watermark?: MeetingsCreateRequestRecordingConfigVideoConfigWatermark;
  /** Width of the recording video in pixels */
  width?: number;
}
export const MeetingsCreateRequestRecordingConfigVideoConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      codec: S.optional(MeetingsCreateRequestRecordingConfigVideoConfigCodec),
      exportFile: S.optional(S.Boolean.pipe(T.Body("export_file"))),
      height: S.optional(S.Number),
      watermark: S.optional(
        MeetingsCreateRequestRecordingConfigVideoConfigWatermark,
      ),
      width: S.optional(S.Number),
    }),
  ).annotate({
    identifier: "MeetingsCreateRequestRecordingConfigVideoConfig",
  }) as any as S.Schema<MeetingsCreateRequestRecordingConfigVideoConfig>;

export interface MeetingsCreateRequestRecordingConfig {
  /** Object containing configuration regarding the audio that is being recorded. */
  audioConfig?: MeetingsCreateRequestRecordingConfigAudioConfig;
  /** Adds a prefix to the beginning of the file name of the recording. */
  fileNamePrefix?: string;
  liveStreamingConfig?: MeetingsCreateRequestRecordingConfigLiveStreamingConfig;
  /** Specifies the maximum duration for recording in seconds, ranging from a minimum of 60 seconds to a maximum of 24 hours. */
  maxSeconds?: number;
  realtimekitBucketConfig?: MeetingsCreateRequestRecordingConfigRealtimekitBucketConfig;
  storageConfig?: MeetingsCreateRequestRecordingConfigStorageConfig;
  videoConfig?: MeetingsCreateRequestRecordingConfigVideoConfig;
}
export const MeetingsCreateRequestRecordingConfig = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      audioConfig: S.optional(
        MeetingsCreateRequestRecordingConfigAudioConfig.pipe(
          T.Body("audio_config"),
        ),
      ),
      fileNamePrefix: S.optional(S.String.pipe(T.Body("file_name_prefix"))),
      liveStreamingConfig: S.optional(
        MeetingsCreateRequestRecordingConfigLiveStreamingConfig.pipe(
          T.Body("live_streaming_config"),
        ),
      ),
      maxSeconds: S.optional(S.Number.pipe(T.Body("max_seconds"))),
      realtimekitBucketConfig: S.optional(
        MeetingsCreateRequestRecordingConfigRealtimekitBucketConfig.pipe(
          T.Body("realtimekit_bucket_config"),
        ),
      ),
      storageConfig: S.optional(
        MeetingsCreateRequestRecordingConfigStorageConfig.pipe(
          T.Body("storage_config"),
        ),
      ),
      videoConfig: S.optional(
        MeetingsCreateRequestRecordingConfigVideoConfig.pipe(
          T.Body("video_config"),
        ),
      ),
    }),
).annotate({
  identifier: "MeetingsCreateRequestRecordingConfig",
}) as any as S.Schema<MeetingsCreateRequestRecordingConfig>;

export interface CreateMeetingRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  /** The AI Config allows you to customize the behavior of meeting transcriptions and summaries */
  aiConfig?: MeetingsCreateRequestAiConfig;
  /** Specifies if the meeting should start getting livestreamed on start. */
  liveStreamOnStart?: boolean;
  /** If a meeting is set to persist_chat, meeting chat would remain for a week within the meeting space. */
  persistChat?: boolean;
  /** Specifies if the meeting should start getting recorded as soon as someone joins the meeting. */
  recordOnStart?: boolean;
  /** Recording Configurations to be used for this meeting. This level of configs takes higher preference over App level configs on the RealtimeKit developer portal. */
  recordingConfig?: MeetingsCreateRequestRecordingConfig;
  /** Time in seconds, for which a session remains active, after the last participant has left the meeting. */
  sessionKeepAliveTimeInSecs?: number;
  /** Automatically generate summary of meetings using transcripts. Requires Transcriptions to be enabled, and can be retrieved via Webhooks or summary API. */
  summarizeOnEnd?: boolean;
  /** Title of the meeting */
  title?: string;
  /** Automatically generate transcripts when the meeting ends. */
  transcribeOnEnd?: boolean;
}
export const CreateMeetingRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    appId: S.String.pipe(T.Label("app_id")),
    aiConfig: S.optional(
      MeetingsCreateRequestAiConfig.pipe(T.Body("ai_config")),
    ),
    liveStreamOnStart: S.optional(
      S.Boolean.pipe(T.Body("live_stream_on_start")),
    ),
    persistChat: S.optional(S.Boolean.pipe(T.Body("persist_chat"))),
    recordOnStart: S.optional(S.Boolean.pipe(T.Body("record_on_start"))),
    recordingConfig: S.optional(
      MeetingsCreateRequestRecordingConfig.pipe(T.Body("recording_config")),
    ),
    sessionKeepAliveTimeInSecs: S.optional(
      S.Number.pipe(T.Body("session_keep_alive_time_in_secs")),
    ),
    summarizeOnEnd: S.optional(S.Boolean.pipe(T.Body("summarize_on_end"))),
    title: S.optional(S.String),
    transcribeOnEnd: S.optional(S.Boolean.pipe(T.Body("transcribe_on_end"))),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/realtime/kit/{app_id}/meetings",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateMeetingRequest",
}) as any as S.Schema<CreateMeetingRequest>;

export type MeetingsCreateResponseDataAiConfigSummarizationSummaryType =
  | "general"
  | "team_meeting"
  | "sales_call"
  | "client_check_in"
  | "interview"
  | "daily_standup"
  | "one_on_one_meeting"
  | "lecture"
  | "code_review";
export const MeetingsCreateResponseDataAiConfigSummarizationSummaryType =
  /*@__PURE__*/ S.String;

export type MeetingsCreateResponseDataAiConfigSummarizationTextFormat =
  | "plain_text"
  | "markdown";
export const MeetingsCreateResponseDataAiConfigSummarizationTextFormat =
  /*@__PURE__*/ S.String;

export interface MeetingsCreateResponseDataAiConfigSummarization {
  /** Defines the style of the summary, such as general, team meeting, or sales call. */
  summaryType?: MeetingsCreateResponseDataAiConfigSummarizationSummaryType | null;
  /** Determines the text format of the summary, such as plain text or markdown. */
  textFormat?: MeetingsCreateResponseDataAiConfigSummarizationTextFormat | null;
  /** Sets the maximum number of words in the meeting summary. */
  wordLimit?: number | null;
}
export const MeetingsCreateResponseDataAiConfigSummarization =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      summaryType: S.optional(
        S.NullOr(
          MeetingsCreateResponseDataAiConfigSummarizationSummaryType,
        ).pipe(T.Body("summary_type")),
      ),
      textFormat: S.optional(
        S.NullOr(
          MeetingsCreateResponseDataAiConfigSummarizationTextFormat,
        ).pipe(T.Body("text_format")),
      ),
      wordLimit: S.optional(S.NullOr(S.Number).pipe(T.Body("word_limit"))),
    }),
  ).annotate({
    identifier: "MeetingsCreateResponseDataAiConfigSummarization",
  }) as any as S.Schema<MeetingsCreateResponseDataAiConfigSummarization>;

export type MeetingsCreateResponseDataAiConfigTranscriptionKeywordsList =
  Array<string>;
export const MeetingsCreateResponseDataAiConfigTranscriptionKeywordsList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<MeetingsCreateResponseDataAiConfigTranscriptionKeywordsList>;

export type MeetingsCreateResponseDataAiConfigTranscriptionLanguage =
  | "en-US"
  | "en-IN"
  | "de"
  | "hi"
  | "sv"
  | "ru"
  | "pl"
  | "el"
  | "fr"
  | "nl";
export const MeetingsCreateResponseDataAiConfigTranscriptionLanguage =
  /*@__PURE__*/ S.String;

export interface MeetingsCreateResponseDataAiConfigTranscription {
  /** Adds specific terms to improve accurate detection during transcription. */
  keywords?: MeetingsCreateResponseDataAiConfigTranscriptionKeywordsList | null;
  /** Specifies the language code for transcription to ensure accurate results. */
  language?: MeetingsCreateResponseDataAiConfigTranscriptionLanguage | null;
  /** Control the inclusion of offensive language in transcriptions. */
  profanityFilter?: boolean | null;
}
export const MeetingsCreateResponseDataAiConfigTranscription =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      keywords: S.optional(
        S.NullOr(MeetingsCreateResponseDataAiConfigTranscriptionKeywordsList),
      ),
      language: S.optional(
        S.NullOr(MeetingsCreateResponseDataAiConfigTranscriptionLanguage),
      ),
      profanityFilter: S.optional(
        S.NullOr(S.Boolean).pipe(T.Body("profanity_filter")),
      ),
    }),
  ).annotate({
    identifier: "MeetingsCreateResponseDataAiConfigTranscription",
  }) as any as S.Schema<MeetingsCreateResponseDataAiConfigTranscription>;

export interface MeetingsCreateResponseDataAiConfig {
  /** Summary Config */
  summarization?: MeetingsCreateResponseDataAiConfigSummarization | null;
  /** Transcription Configurations */
  transcription?: MeetingsCreateResponseDataAiConfigTranscription | null;
}
export const MeetingsCreateResponseDataAiConfig = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    summarization: S.optional(
      S.NullOr(MeetingsCreateResponseDataAiConfigSummarization),
    ),
    transcription: S.optional(
      S.NullOr(MeetingsCreateResponseDataAiConfigTranscription),
    ),
  }),
).annotate({
  identifier: "MeetingsCreateResponseDataAiConfig",
}) as any as S.Schema<MeetingsCreateResponseDataAiConfig>;

export type MeetingsCreateResponseDataRecordingConfigAudioConfigChannel =
  | "mono"
  | "stereo";
export const MeetingsCreateResponseDataRecordingConfigAudioConfigChannel =
  /*@__PURE__*/ S.String;

export type MeetingsCreateResponseDataRecordingConfigAudioConfigCodec =
  | "MP3"
  | "AAC";
export const MeetingsCreateResponseDataRecordingConfigAudioConfigCodec =
  /*@__PURE__*/ S.String;

export interface MeetingsCreateResponseDataRecordingConfigAudioConfig {
  /** Audio signal pathway within an audio file that carries a specific sound source. */
  channel?: MeetingsCreateResponseDataRecordingConfigAudioConfigChannel | null;
  /** Codec using which the recording will be encoded. If VP8/VP9 is selected for videoConfig, changing audioConfig is not allowed. In this case, the codec in the audioConfig is automatically set to vorbis. */
  codec?: MeetingsCreateResponseDataRecordingConfigAudioConfigCodec | null;
  /** Controls whether to export audio file seperately */
  exportFile?: boolean | null;
}
export const MeetingsCreateResponseDataRecordingConfigAudioConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      channel: S.optional(
        S.NullOr(MeetingsCreateResponseDataRecordingConfigAudioConfigChannel),
      ),
      codec: S.optional(
        S.NullOr(MeetingsCreateResponseDataRecordingConfigAudioConfigCodec),
      ),
      exportFile: S.optional(S.NullOr(S.Boolean).pipe(T.Body("export_file"))),
    }),
  ).annotate({
    identifier: "MeetingsCreateResponseDataRecordingConfigAudioConfig",
  }) as any as S.Schema<MeetingsCreateResponseDataRecordingConfigAudioConfig>;

export interface MeetingsCreateResponseDataRecordingConfigLiveStreamingConfig {
  /** RTMP URL to stream to */
  rtmpUrl?: string | null;
}
export const MeetingsCreateResponseDataRecordingConfigLiveStreamingConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      rtmpUrl: S.optional(S.NullOr(S.String).pipe(T.Body("rtmp_url"))),
    }),
  ).annotate({
    identifier: "MeetingsCreateResponseDataRecordingConfigLiveStreamingConfig",
  }) as any as S.Schema<MeetingsCreateResponseDataRecordingConfigLiveStreamingConfig>;

export type MeetingsCreateResponseDataRecordingConfigRealtimekitBucketConfig =
  MeetingsCreateRequestRecordingConfigRealtimekitBucketConfig;
export const MeetingsCreateResponseDataRecordingConfigRealtimekitBucketConfig =
  MeetingsCreateRequestRecordingConfigRealtimekitBucketConfig;

export type MeetingsCreateResponseDataRecordingConfigStorageConfigType =
  | "aws"
  | "azure"
  | "digitalocean"
  | "gcs"
  | "sftp";
export const MeetingsCreateResponseDataRecordingConfigStorageConfigType =
  /*@__PURE__*/ S.String;

export type MeetingsCreateResponseDataRecordingConfigStorageConfigAuthMethod =
  | "KEY"
  | "PASSWORD";
export const MeetingsCreateResponseDataRecordingConfigStorageConfigAuthMethod =
  /*@__PURE__*/ S.String;

export interface MeetingsCreateResponseDataRecordingConfigStorageConfig {
  /** Type of storage media. */
  type: MeetingsCreateResponseDataRecordingConfigStorageConfigType;
  /** Access key of the storage medium. Access key is not required for the `gcs` storage media type. */
  accessKey?: string | null;
  /** Authentication method used for "sftp" type storage medium */
  authMethod?: MeetingsCreateResponseDataRecordingConfigStorageConfigAuthMethod | null;
  /** Name of the storage medium's bucket. */
  bucket?: string | null;
  /** SSH destination server host for SFTP type storage medium */
  host?: string | null;
  /** SSH destination server password for SFTP type storage medium when auth_method is "PASSWORD". If auth_method is "KEY", this specifies the password for the ssh private key. */
  password?: string | null;
  /** Path relative to the bucket root at which the recording will be placed. */
  path?: string | null;
  /** SSH destination server port for SFTP type storage medium */
  port?: number | null;
  /** Private key used to login to destination SSH server for SFTP type storage medium, when auth_method used is "KEY" */
  privateKey?: string | null;
  /** Region of the storage medium. */
  region?: string | null;
  /** Secret key of the storage medium. Similar to `access_key`, it is only writeable by clients, not readable. */
  secret?: string | null;
  /** SSH destination server username for SFTP type storage medium */
  username?: string | null;
}
export const MeetingsCreateResponseDataRecordingConfigStorageConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: MeetingsCreateResponseDataRecordingConfigStorageConfigType,
      accessKey: S.optional(S.NullOr(S.String).pipe(T.Body("access_key"))),
      authMethod: S.optional(
        S.NullOr(
          MeetingsCreateResponseDataRecordingConfigStorageConfigAuthMethod,
        ).pipe(T.Body("auth_method")),
      ),
      bucket: S.optional(S.NullOr(S.String)),
      host: S.optional(S.NullOr(S.String)),
      password: S.optional(S.NullOr(S.String)),
      path: S.optional(S.NullOr(S.String)),
      port: S.optional(S.NullOr(S.Number)),
      privateKey: S.optional(S.NullOr(S.String).pipe(T.Body("private_key"))),
      region: S.optional(S.NullOr(S.String)),
      secret: S.optional(S.NullOr(S.String)),
      username: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier: "MeetingsCreateResponseDataRecordingConfigStorageConfig",
  }) as any as S.Schema<MeetingsCreateResponseDataRecordingConfigStorageConfig>;

export type MeetingsCreateResponseDataRecordingConfigVideoConfigCodec =
  | "H264"
  | "VP8";
export const MeetingsCreateResponseDataRecordingConfigVideoConfigCodec =
  /*@__PURE__*/ S.String;

export type MeetingsCreateResponseDataRecordingConfigVideoConfigWatermarkPosition =
  | "left top"
  | "right top"
  | "left bottom"
  | "right bottom";
export const MeetingsCreateResponseDataRecordingConfigVideoConfigWatermarkPosition =
  /*@__PURE__*/ S.String;

export interface MeetingsCreateResponseDataRecordingConfigVideoConfigWatermarkSize {
  /** Height of the watermark in px */
  height?: number | null;
  /** Width of the watermark in px */
  width?: number | null;
}
export const MeetingsCreateResponseDataRecordingConfigVideoConfigWatermarkSize =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      height: S.optional(S.NullOr(S.Number)),
      width: S.optional(S.NullOr(S.Number)),
    }),
  ).annotate({
    identifier:
      "MeetingsCreateResponseDataRecordingConfigVideoConfigWatermarkSize",
  }) as any as S.Schema<MeetingsCreateResponseDataRecordingConfigVideoConfigWatermarkSize>;

export interface MeetingsCreateResponseDataRecordingConfigVideoConfigWatermark {
  /** Position of the watermark */
  position?: MeetingsCreateResponseDataRecordingConfigVideoConfigWatermarkPosition | null;
  /** Size of the watermark */
  size?: MeetingsCreateResponseDataRecordingConfigVideoConfigWatermarkSize | null;
  /** URL of the watermark image */
  url?: string | null;
}
export const MeetingsCreateResponseDataRecordingConfigVideoConfigWatermark =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      position: S.optional(
        S.NullOr(
          MeetingsCreateResponseDataRecordingConfigVideoConfigWatermarkPosition,
        ),
      ),
      size: S.optional(
        S.NullOr(
          MeetingsCreateResponseDataRecordingConfigVideoConfigWatermarkSize,
        ),
      ),
      url: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier: "MeetingsCreateResponseDataRecordingConfigVideoConfigWatermark",
  }) as any as S.Schema<MeetingsCreateResponseDataRecordingConfigVideoConfigWatermark>;

export interface MeetingsCreateResponseDataRecordingConfigVideoConfig {
  /** Codec using which the recording will be encoded. */
  codec?: MeetingsCreateResponseDataRecordingConfigVideoConfigCodec | null;
  /** Controls whether to export video file seperately */
  exportFile?: boolean | null;
  /** Height of the recording video in pixels */
  height?: number | null;
  /** Watermark to be added to the recording */
  watermark?: MeetingsCreateResponseDataRecordingConfigVideoConfigWatermark | null;
  /** Width of the recording video in pixels */
  width?: number | null;
}
export const MeetingsCreateResponseDataRecordingConfigVideoConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      codec: S.optional(
        S.NullOr(MeetingsCreateResponseDataRecordingConfigVideoConfigCodec),
      ),
      exportFile: S.optional(S.NullOr(S.Boolean).pipe(T.Body("export_file"))),
      height: S.optional(S.NullOr(S.Number)),
      watermark: S.optional(
        S.NullOr(MeetingsCreateResponseDataRecordingConfigVideoConfigWatermark),
      ),
      width: S.optional(S.NullOr(S.Number)),
    }),
  ).annotate({
    identifier: "MeetingsCreateResponseDataRecordingConfigVideoConfig",
  }) as any as S.Schema<MeetingsCreateResponseDataRecordingConfigVideoConfig>;

export interface MeetingsCreateResponseDataRecordingConfig {
  /** Object containing configuration regarding the audio that is being recorded. */
  audioConfig?: MeetingsCreateResponseDataRecordingConfigAudioConfig | null;
  /** Adds a prefix to the beginning of the file name of the recording. */
  fileNamePrefix?: string | null;
  liveStreamingConfig?: MeetingsCreateResponseDataRecordingConfigLiveStreamingConfig | null;
  /** Specifies the maximum duration for recording in seconds, ranging from a minimum of 60 seconds to a maximum of 24 hours. */
  maxSeconds?: number | null;
  realtimekitBucketConfig?: MeetingsCreateRequestRecordingConfigRealtimekitBucketConfig | null;
  storageConfig?: MeetingsCreateResponseDataRecordingConfigStorageConfig | null;
  videoConfig?: MeetingsCreateResponseDataRecordingConfigVideoConfig | null;
}
export const MeetingsCreateResponseDataRecordingConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      audioConfig: S.optional(
        S.NullOr(MeetingsCreateResponseDataRecordingConfigAudioConfig).pipe(
          T.Body("audio_config"),
        ),
      ),
      fileNamePrefix: S.optional(
        S.NullOr(S.String).pipe(T.Body("file_name_prefix")),
      ),
      liveStreamingConfig: S.optional(
        S.NullOr(
          MeetingsCreateResponseDataRecordingConfigLiveStreamingConfig,
        ).pipe(T.Body("live_streaming_config")),
      ),
      maxSeconds: S.optional(S.NullOr(S.Number).pipe(T.Body("max_seconds"))),
      realtimekitBucketConfig: S.optional(
        S.NullOr(
          MeetingsCreateRequestRecordingConfigRealtimekitBucketConfig,
        ).pipe(T.Body("realtimekit_bucket_config")),
      ),
      storageConfig: S.optional(
        S.NullOr(MeetingsCreateResponseDataRecordingConfigStorageConfig).pipe(
          T.Body("storage_config"),
        ),
      ),
      videoConfig: S.optional(
        S.NullOr(MeetingsCreateResponseDataRecordingConfigVideoConfig).pipe(
          T.Body("video_config"),
        ),
      ),
    }),
  ).annotate({
    identifier: "MeetingsCreateResponseDataRecordingConfig",
  }) as any as S.Schema<MeetingsCreateResponseDataRecordingConfig>;

export type MeetingsCreateResponseDataStatus = "ACTIVE" | "INACTIVE";
export const MeetingsCreateResponseDataStatus = /*@__PURE__*/ S.String;

export interface MeetingsCreateResponseData {
  /** ID of the meeting. */
  id: string;
  /** Timestamp the object was created at. The time is returned in ISO format. */
  createdAt: string;
  /** Timestamp the object was updated at. The time is returned in ISO format. */
  updatedAt: string;
  /** The AI Config allows you to customize the behavior of meeting transcriptions and summaries */
  aiConfig?: MeetingsCreateResponseDataAiConfig | null;
  /** Specifies if the meeting should start getting livestreamed on start. */
  liveStreamOnStart?: boolean | null;
  /** Specifies if Chat within a meeting should persist for a week. */
  persistChat?: boolean | null;
  /** Specifies if the meeting should start getting recorded as soon as someone joins the meeting. */
  recordOnStart?: boolean | null;
  /** Recording Configurations to be used for this meeting. This level of configs takes higher preference over App level configs on the RealtimeKit developer portal. */
  recordingConfig?: MeetingsCreateResponseDataRecordingConfig | null;
  /** Time in seconds, for which a session remains active, after the last participant has left the meeting. */
  sessionKeepAliveTimeInSecs?: number | null;
  /** Whether the meeting is `ACTIVE` or `INACTIVE`. Users will not be able to join an `INACTIVE` meeting. */
  status?: MeetingsCreateResponseDataStatus | null;
  /** Automatically generate summary of meetings using transcripts. Requires Transcriptions to be enabled, and can be retrieved via Webhooks or summary API. */
  summarizeOnEnd?: boolean | null;
  /** Title of the meeting. */
  title?: string | null;
  /** Automatically generate transcripts when the meeting ends. */
  transcribeOnEnd?: boolean | null;
}
export const MeetingsCreateResponseData = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    createdAt: S.String.pipe(T.Body("created_at")),
    updatedAt: S.String.pipe(T.Body("updated_at")),
    aiConfig: S.optional(
      S.NullOr(MeetingsCreateResponseDataAiConfig).pipe(T.Body("ai_config")),
    ),
    liveStreamOnStart: S.optional(
      S.NullOr(S.Boolean).pipe(T.Body("live_stream_on_start")),
    ),
    persistChat: S.optional(S.NullOr(S.Boolean).pipe(T.Body("persist_chat"))),
    recordOnStart: S.optional(
      S.NullOr(S.Boolean).pipe(T.Body("record_on_start")),
    ),
    recordingConfig: S.optional(
      S.NullOr(MeetingsCreateResponseDataRecordingConfig).pipe(
        T.Body("recording_config"),
      ),
    ),
    sessionKeepAliveTimeInSecs: S.optional(
      S.NullOr(S.Number).pipe(T.Body("session_keep_alive_time_in_secs")),
    ),
    status: S.optional(S.NullOr(MeetingsCreateResponseDataStatus)),
    summarizeOnEnd: S.optional(
      S.NullOr(S.Boolean).pipe(T.Body("summarize_on_end")),
    ),
    title: S.optional(S.NullOr(S.String)),
    transcribeOnEnd: S.optional(
      S.NullOr(S.Boolean).pipe(T.Body("transcribe_on_end")),
    ),
  }),
).annotate({
  identifier: "MeetingsCreateResponseData",
}) as any as S.Schema<MeetingsCreateResponseData>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface CreateMeetingResponse {
  /** Data returned by the operation */
  data?: MeetingsCreateResponseData | null;
}
export const CreateMeetingResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    data: S.optional(S.NullOr(MeetingsCreateResponseData)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateMeetingResponse",
}) as any as S.Schema<CreateMeetingResponse>;

export type ActiveSessionCreatePollRequestOptionsList = Array<string>;
export const ActiveSessionCreatePollRequestOptionsList = /*@__PURE__*/ S.Array(
  S.String,
) as any as S.Schema<ActiveSessionCreatePollRequestOptionsList>;

export interface CreatePollActiveSessionRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  meetingId: string;
  /** Different options for the question */
  options: ActiveSessionCreatePollRequestOptionsList;
  /** Question of the poll */
  question: string;
  /** if voters on a poll are anonymous */
  anonymous?: boolean;
  /** if votes on an option are visible before a person votes */
  hideVotes?: boolean;
}
export const CreatePollActiveSessionRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    appId: S.String.pipe(T.Label("app_id")),
    meetingId: S.String.pipe(T.Label("meeting_id")),
    options: ActiveSessionCreatePollRequestOptionsList,
    question: S.String,
    anonymous: S.optional(S.Boolean),
    hideVotes: S.optional(S.Boolean.pipe(T.Body("hide_votes"))),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/realtime/kit/{app_id}/meetings/{meeting_id}/active-session/poll",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreatePollActiveSessionRequest",
}) as any as S.Schema<CreatePollActiveSessionRequest>;

export interface ActiveSessionCreatePollResponseDataPollOptionsItemVotesItem {
  id: string;
  name: string;
}
export const ActiveSessionCreatePollResponseDataPollOptionsItemVotesItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      name: S.String,
    }),
  ).annotate({
    identifier: "ActiveSessionCreatePollResponseDataPollOptionsItemVotesItem",
  }) as any as S.Schema<ActiveSessionCreatePollResponseDataPollOptionsItemVotesItem>;

export type ActiveSessionCreatePollResponseDataPollOptionsItemVotesList =
  Array<ActiveSessionCreatePollResponseDataPollOptionsItemVotesItem>;
export const ActiveSessionCreatePollResponseDataPollOptionsItemVotesList =
  /*@__PURE__*/ S.Array(
    ActiveSessionCreatePollResponseDataPollOptionsItemVotesItem,
  ) as any as S.Schema<ActiveSessionCreatePollResponseDataPollOptionsItemVotesList>;

export interface ActiveSessionCreatePollResponseDataPollOptionsItem {
  count: number;
  /** Text of the answer option */
  text: string;
  votes: ActiveSessionCreatePollResponseDataPollOptionsItemVotesList;
}
export const ActiveSessionCreatePollResponseDataPollOptionsItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      count: S.Number,
      text: S.String,
      votes: ActiveSessionCreatePollResponseDataPollOptionsItemVotesList,
    }),
  ).annotate({
    identifier: "ActiveSessionCreatePollResponseDataPollOptionsItem",
  }) as any as S.Schema<ActiveSessionCreatePollResponseDataPollOptionsItem>;

export type ActiveSessionCreatePollResponseDataPollOptionsList =
  Array<ActiveSessionCreatePollResponseDataPollOptionsItem>;
export const ActiveSessionCreatePollResponseDataPollOptionsList =
  /*@__PURE__*/ S.Array(
    ActiveSessionCreatePollResponseDataPollOptionsItem,
  ) as any as S.Schema<ActiveSessionCreatePollResponseDataPollOptionsList>;

export type ActiveSessionCreatePollResponseDataPollVotedList = Array<string>;
export const ActiveSessionCreatePollResponseDataPollVotedList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<ActiveSessionCreatePollResponseDataPollVotedList>;

export interface ActiveSessionCreatePollResponseDataPoll {
  /** ID of the poll */
  id: string;
  /** Answer options */
  options: ActiveSessionCreatePollResponseDataPollOptionsList;
  /** Question asked by the poll */
  question: string;
  anonymous?: boolean | null;
  createdBy?: string | null;
  hideVotes?: boolean | null;
  voted?: ActiveSessionCreatePollResponseDataPollVotedList | null;
}
export const ActiveSessionCreatePollResponseDataPoll = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.String,
      options: ActiveSessionCreatePollResponseDataPollOptionsList,
      question: S.String,
      anonymous: S.optional(S.NullOr(S.Boolean)),
      createdBy: S.optional(S.NullOr(S.String).pipe(T.Body("created_by"))),
      hideVotes: S.optional(S.NullOr(S.Boolean).pipe(T.Body("hide_votes"))),
      voted: S.optional(
        S.NullOr(ActiveSessionCreatePollResponseDataPollVotedList),
      ),
    }),
).annotate({
  identifier: "ActiveSessionCreatePollResponseDataPoll",
}) as any as S.Schema<ActiveSessionCreatePollResponseDataPoll>;

export interface ActiveSessionCreatePollResponseData {
  action?: string | null;
  poll?: ActiveSessionCreatePollResponseDataPoll | null;
}
export const ActiveSessionCreatePollResponseData = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    action: S.optional(S.NullOr(S.String)),
    poll: S.optional(S.NullOr(ActiveSessionCreatePollResponseDataPoll)),
  }),
).annotate({
  identifier: "ActiveSessionCreatePollResponseData",
}) as any as S.Schema<ActiveSessionCreatePollResponseData>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface CreatePollActiveSessionResponse {
  data?: ActiveSessionCreatePollResponseData | null;
}
export const CreatePollActiveSessionResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    data: S.optional(S.NullOr(ActiveSessionCreatePollResponseData)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreatePollActiveSessionResponse",
}) as any as S.Schema<CreatePollActiveSessionResponse>;

export interface PresetsCreateRequestConfigMaxVideoStreams {
  /** Maximum number of video streams visible on desktop devices */
  desktop: number;
  /** Maximum number of streams visible on mobile devices */
  mobile: number;
}
export const PresetsCreateRequestConfigMaxVideoStreams =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      desktop: S.Number,
      mobile: S.Number,
    }),
  ).annotate({
    identifier: "PresetsCreateRequestConfigMaxVideoStreams",
  }) as any as S.Schema<PresetsCreateRequestConfigMaxVideoStreams>;

export type PresetsCreateRequestConfigMediaScreenshareQuality =
  | "hd"
  | "vga"
  | "qvga"
  | "fhd"
  | "uhd";
export const PresetsCreateRequestConfigMediaScreenshareQuality =
  /*@__PURE__*/ S.String;

export interface PresetsCreateRequestConfigMediaScreenshare {
  /** Frame rate of screen share */
  frameRate: number;
  /** Quality of screen share */
  quality: PresetsCreateRequestConfigMediaScreenshareQuality | (string & {});
}
export const PresetsCreateRequestConfigMediaScreenshare =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      frameRate: S.Number.pipe(T.Body("frame_rate")),
      quality: PresetsCreateRequestConfigMediaScreenshareQuality,
    }),
  ).annotate({
    identifier: "PresetsCreateRequestConfigMediaScreenshare",
  }) as any as S.Schema<PresetsCreateRequestConfigMediaScreenshare>;

export type PresetsCreateRequestConfigMediaVideoQuality =
  | "hd"
  | "vga"
  | "qvga"
  | "fhd"
  | "uhd";
export const PresetsCreateRequestConfigMediaVideoQuality =
  /*@__PURE__*/ S.String;

export interface PresetsCreateRequestConfigMediaVideo {
  /** Frame rate of participants' video */
  frameRate: number;
  /** Video quality of participants */
  quality: PresetsCreateRequestConfigMediaVideoQuality | (string & {});
  /** Enable simulcast for participant videos. */
  simulcast?: boolean;
}
export const PresetsCreateRequestConfigMediaVideo = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      frameRate: S.Number.pipe(T.Body("frame_rate")),
      quality: PresetsCreateRequestConfigMediaVideoQuality,
      simulcast: S.optional(S.Boolean),
    }),
).annotate({
  identifier: "PresetsCreateRequestConfigMediaVideo",
}) as any as S.Schema<PresetsCreateRequestConfigMediaVideo>;

export interface PresetsCreateRequestConfigMediaAudio {
  /** Enable High Quality Audio for your meetings */
  enableHighBitrate?: boolean;
  /** Enable Stereo for your meetings */
  enableStereo?: boolean;
}
export const PresetsCreateRequestConfigMediaAudio = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      enableHighBitrate: S.optional(
        S.Boolean.pipe(T.Body("enable_high_bitrate")),
      ),
      enableStereo: S.optional(S.Boolean.pipe(T.Body("enable_stereo"))),
    }),
).annotate({
  identifier: "PresetsCreateRequestConfigMediaAudio",
}) as any as S.Schema<PresetsCreateRequestConfigMediaAudio>;

export interface PresetsCreateRequestConfigMedia {
  /** Configuration options for participant screen shares */
  screenshare: PresetsCreateRequestConfigMediaScreenshare;
  /** Configuration options for participant videos */
  video: PresetsCreateRequestConfigMediaVideo;
  /** Control options for Audio quality. */
  audio?: PresetsCreateRequestConfigMediaAudio;
}
export const PresetsCreateRequestConfigMedia = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    screenshare: PresetsCreateRequestConfigMediaScreenshare,
    video: PresetsCreateRequestConfigMediaVideo,
    audio: S.optional(PresetsCreateRequestConfigMediaAudio),
  }),
).annotate({
  identifier: "PresetsCreateRequestConfigMedia",
}) as any as S.Schema<PresetsCreateRequestConfigMedia>;

export type PresetsCreateRequestConfigViewType =
  | "GROUP_CALL"
  | "WEBINAR"
  | "AUDIO_ROOM"
  | "LIVESTREAM";
export const PresetsCreateRequestConfigViewType = /*@__PURE__*/ S.String;

export type PresetsCreateRequestConfigLivestreamViewerQualitiesList =
  Array<number>;
export const PresetsCreateRequestConfigLivestreamViewerQualitiesList =
  /*@__PURE__*/ S.Array(
    S.Number,
  ) as any as S.Schema<PresetsCreateRequestConfigLivestreamViewerQualitiesList>;

export interface PresetsCreateRequestConfig {
  /** Maximum number of screen shares that can be active at a given time */
  maxScreenshareCount: number;
  /** Maximum number of streams that are visible on a device */
  maxVideoStreams: PresetsCreateRequestConfigMaxVideoStreams;
  /** Media configuration options. eg: Video quality */
  media: PresetsCreateRequestConfigMedia;
  /** Type of the meeting */
  viewType: PresetsCreateRequestConfigViewType | (string & {});
  /** Livestream viewer quality levels. */
  livestreamViewerQualities?: PresetsCreateRequestConfigLivestreamViewerQualitiesList;
}
export const PresetsCreateRequestConfig = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    maxScreenshareCount: S.Number.pipe(T.Body("max_screenshare_count")),
    maxVideoStreams: PresetsCreateRequestConfigMaxVideoStreams.pipe(
      T.Body("max_video_streams"),
    ),
    media: PresetsCreateRequestConfigMedia,
    viewType: PresetsCreateRequestConfigViewType.pipe(T.Body("view_type")),
    livestreamViewerQualities: S.optional(
      PresetsCreateRequestConfigLivestreamViewerQualitiesList.pipe(
        T.Body("livestream_viewer_qualities"),
      ),
    ),
  }),
).annotate({
  identifier: "PresetsCreateRequestConfig",
}) as any as S.Schema<PresetsCreateRequestConfig>;

export interface PresetsCreateRequestPermissionsChatPrivate {
  canReceive: boolean;
  canSend: boolean;
  files: boolean;
  text: boolean;
}
export const PresetsCreateRequestPermissionsChatPrivate =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      canReceive: S.Boolean.pipe(T.Body("can_receive")),
      canSend: S.Boolean.pipe(T.Body("can_send")),
      files: S.Boolean,
      text: S.Boolean,
    }),
  ).annotate({
    identifier: "PresetsCreateRequestPermissionsChatPrivate",
  }) as any as S.Schema<PresetsCreateRequestPermissionsChatPrivate>;

export interface PresetsCreateRequestPermissionsChatPublic {
  /** Can send messages in general */
  canSend: boolean;
  /** Can send file messages */
  files: boolean;
  /** Can send text messages */
  text: boolean;
}
export const PresetsCreateRequestPermissionsChatPublic =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      canSend: S.Boolean.pipe(T.Body("can_send")),
      files: S.Boolean,
      text: S.Boolean,
    }),
  ).annotate({
    identifier: "PresetsCreateRequestPermissionsChatPublic",
  }) as any as S.Schema<PresetsCreateRequestPermissionsChatPublic>;

export interface PresetsCreateRequestPermissionsChat {
  private: PresetsCreateRequestPermissionsChatPrivate;
  public: PresetsCreateRequestPermissionsChatPublic;
}
export const PresetsCreateRequestPermissionsChat = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    private: PresetsCreateRequestPermissionsChatPrivate,
    public: PresetsCreateRequestPermissionsChatPublic,
  }),
).annotate({
  identifier: "PresetsCreateRequestPermissionsChat",
}) as any as S.Schema<PresetsCreateRequestPermissionsChat>;

export interface PresetsCreateRequestPermissionsConnectedMeetings {
  canAlterConnectedMeetings: boolean;
  canSwitchConnectedMeetings: boolean;
  canSwitchToParentMeeting: boolean;
}
export const PresetsCreateRequestPermissionsConnectedMeetings =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      canAlterConnectedMeetings: S.Boolean.pipe(
        T.Body("can_alter_connected_meetings"),
      ),
      canSwitchConnectedMeetings: S.Boolean.pipe(
        T.Body("can_switch_connected_meetings"),
      ),
      canSwitchToParentMeeting: S.Boolean.pipe(
        T.Body("can_switch_to_parent_meeting"),
      ),
    }),
  ).annotate({
    identifier: "PresetsCreateRequestPermissionsConnectedMeetings",
  }) as any as S.Schema<PresetsCreateRequestPermissionsConnectedMeetings>;

export type PresetsCreateRequestPermissionsMediaAudioCanProduce =
  | "ALLOWED"
  | "NOT_ALLOWED"
  | "CAN_REQUEST";
export const PresetsCreateRequestPermissionsMediaAudioCanProduce =
  /*@__PURE__*/ S.String;

export interface PresetsCreateRequestPermissionsMediaAudio {
  /** Can produce audio */
  canProduce:
    | PresetsCreateRequestPermissionsMediaAudioCanProduce
    | (string & {});
}
export const PresetsCreateRequestPermissionsMediaAudio =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      canProduce: PresetsCreateRequestPermissionsMediaAudioCanProduce.pipe(
        T.Body("can_produce"),
      ),
    }),
  ).annotate({
    identifier: "PresetsCreateRequestPermissionsMediaAudio",
  }) as any as S.Schema<PresetsCreateRequestPermissionsMediaAudio>;

export type PresetsCreateRequestPermissionsMediaScreenshareCanProduce =
  | "ALLOWED"
  | "NOT_ALLOWED"
  | "CAN_REQUEST";
export const PresetsCreateRequestPermissionsMediaScreenshareCanProduce =
  /*@__PURE__*/ S.String;

export interface PresetsCreateRequestPermissionsMediaScreenshare {
  /** Can produce screen share video */
  canProduce:
    | PresetsCreateRequestPermissionsMediaScreenshareCanProduce
    | (string & {});
}
export const PresetsCreateRequestPermissionsMediaScreenshare =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      canProduce:
        PresetsCreateRequestPermissionsMediaScreenshareCanProduce.pipe(
          T.Body("can_produce"),
        ),
    }),
  ).annotate({
    identifier: "PresetsCreateRequestPermissionsMediaScreenshare",
  }) as any as S.Schema<PresetsCreateRequestPermissionsMediaScreenshare>;

export type PresetsCreateRequestPermissionsMediaVideoCanProduce =
  | "ALLOWED"
  | "NOT_ALLOWED"
  | "CAN_REQUEST";
export const PresetsCreateRequestPermissionsMediaVideoCanProduce =
  /*@__PURE__*/ S.String;

export interface PresetsCreateRequestPermissionsMediaVideo {
  /** Can produce video */
  canProduce:
    | PresetsCreateRequestPermissionsMediaVideoCanProduce
    | (string & {});
}
export const PresetsCreateRequestPermissionsMediaVideo =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      canProduce: PresetsCreateRequestPermissionsMediaVideoCanProduce.pipe(
        T.Body("can_produce"),
      ),
    }),
  ).annotate({
    identifier: "PresetsCreateRequestPermissionsMediaVideo",
  }) as any as S.Schema<PresetsCreateRequestPermissionsMediaVideo>;

export interface PresetsCreateRequestPermissionsMedia {
  /** Audio permissions */
  audio: PresetsCreateRequestPermissionsMediaAudio;
  /** Screenshare permissions */
  screenshare: PresetsCreateRequestPermissionsMediaScreenshare;
  /** Video permissions */
  video: PresetsCreateRequestPermissionsMediaVideo;
}
export const PresetsCreateRequestPermissionsMedia = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      audio: PresetsCreateRequestPermissionsMediaAudio,
      screenshare: PresetsCreateRequestPermissionsMediaScreenshare,
      video: PresetsCreateRequestPermissionsMediaVideo,
    }),
).annotate({
  identifier: "PresetsCreateRequestPermissionsMedia",
}) as any as S.Schema<PresetsCreateRequestPermissionsMedia>;

export interface PresetsCreateRequestPermissionsPlugins {
  /** Can close plugins that are already open */
  canClose: boolean;
  /** Can edit plugin config */
  canEditConfig: boolean;
  /** Can start plugins */
  canStart: boolean;
  /** Plugin configuration keyed by plugin UUID. */
  config: unknown;
}
export const PresetsCreateRequestPermissionsPlugins = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      canClose: S.Boolean.pipe(T.Body("can_close")),
      canEditConfig: S.Boolean.pipe(T.Body("can_edit_config")),
      canStart: S.Boolean.pipe(T.Body("can_start")),
      config: S.Unknown,
    }),
).annotate({
  identifier: "PresetsCreateRequestPermissionsPlugins",
}) as any as S.Schema<PresetsCreateRequestPermissionsPlugins>;

export interface PresetsCreateRequestPermissionsPolls {
  /** Can create polls */
  canCreate: boolean;
  /** Can view polls */
  canView: boolean;
  /** Can vote on polls */
  canVote: boolean;
}
export const PresetsCreateRequestPermissionsPolls = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      canCreate: S.Boolean.pipe(T.Body("can_create")),
      canView: S.Boolean.pipe(T.Body("can_view")),
      canVote: S.Boolean.pipe(T.Body("can_vote")),
    }),
).annotate({
  identifier: "PresetsCreateRequestPermissionsPolls",
}) as any as S.Schema<PresetsCreateRequestPermissionsPolls>;

export type PresetsCreateRequestPermissionsRecorderType =
  | "RECORDER"
  | "LIVESTREAMER"
  | "NONE";
export const PresetsCreateRequestPermissionsRecorderType =
  /*@__PURE__*/ S.String;

export type PresetsCreateRequestPermissionsWaitingRoomType =
  | "SKIP"
  | "ON_PRIVILEGED_USER_ENTRY"
  | "SKIP_ON_ACCEPT";
export const PresetsCreateRequestPermissionsWaitingRoomType =
  /*@__PURE__*/ S.String;

export type PresetsCreateRequestPermissionsStageAccess =
  | "ALLOWED"
  | "NOT_ALLOWED"
  | "CAN_REQUEST";
export const PresetsCreateRequestPermissionsStageAccess =
  /*@__PURE__*/ S.String;

export interface PresetsCreateRequestPermissions {
  /** Whether this participant can accept waiting requests */
  acceptWaitingRequests: boolean;
  canAcceptProductionRequests: boolean;
  canChangeParticipantPermissions: boolean;
  canEditDisplayName: boolean;
  canLivestream: boolean;
  canRecord: boolean;
  canSpotlight: boolean;
  chat: PresetsCreateRequestPermissionsChat;
  connectedMeetings: PresetsCreateRequestPermissionsConnectedMeetings;
  disableParticipantAudio: boolean;
  disableParticipantScreensharing: boolean;
  disableParticipantVideo: boolean;
  /** Whether this participant is visible to others or not */
  hiddenParticipant: boolean;
  kickParticipant: boolean;
  /** Media permissions */
  media: PresetsCreateRequestPermissionsMedia;
  pinParticipant: boolean;
  /** Plugin permissions */
  plugins: PresetsCreateRequestPermissionsPlugins;
  /** Poll permissions */
  polls: PresetsCreateRequestPermissionsPolls;
  /** Type of the recording peer */
  recorderType: PresetsCreateRequestPermissionsRecorderType | (string & {});
  showParticipantList: boolean;
  /** Waiting room type */
  waitingRoomType:
    | PresetsCreateRequestPermissionsWaitingRoomType
    | (string & {});
  acceptStageRequests?: boolean;
  isRecorder?: boolean;
  stageAccess?: PresetsCreateRequestPermissionsStageAccess | (string & {});
  stageEnabled?: boolean;
  transcriptionEnabled?: boolean;
}
export const PresetsCreateRequestPermissions = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    acceptWaitingRequests: S.Boolean.pipe(T.Body("accept_waiting_requests")),
    canAcceptProductionRequests: S.Boolean.pipe(
      T.Body("can_accept_production_requests"),
    ),
    canChangeParticipantPermissions: S.Boolean.pipe(
      T.Body("can_change_participant_permissions"),
    ),
    canEditDisplayName: S.Boolean.pipe(T.Body("can_edit_display_name")),
    canLivestream: S.Boolean.pipe(T.Body("can_livestream")),
    canRecord: S.Boolean.pipe(T.Body("can_record")),
    canSpotlight: S.Boolean.pipe(T.Body("can_spotlight")),
    chat: PresetsCreateRequestPermissionsChat,
    connectedMeetings: PresetsCreateRequestPermissionsConnectedMeetings.pipe(
      T.Body("connected_meetings"),
    ),
    disableParticipantAudio: S.Boolean.pipe(
      T.Body("disable_participant_audio"),
    ),
    disableParticipantScreensharing: S.Boolean.pipe(
      T.Body("disable_participant_screensharing"),
    ),
    disableParticipantVideo: S.Boolean.pipe(
      T.Body("disable_participant_video"),
    ),
    hiddenParticipant: S.Boolean.pipe(T.Body("hidden_participant")),
    kickParticipant: S.Boolean.pipe(T.Body("kick_participant")),
    media: PresetsCreateRequestPermissionsMedia,
    pinParticipant: S.Boolean.pipe(T.Body("pin_participant")),
    plugins: PresetsCreateRequestPermissionsPlugins,
    polls: PresetsCreateRequestPermissionsPolls,
    recorderType: PresetsCreateRequestPermissionsRecorderType.pipe(
      T.Body("recorder_type"),
    ),
    showParticipantList: S.Boolean.pipe(T.Body("show_participant_list")),
    waitingRoomType: PresetsCreateRequestPermissionsWaitingRoomType.pipe(
      T.Body("waiting_room_type"),
    ),
    acceptStageRequests: S.optional(
      S.Boolean.pipe(T.Body("accept_stage_requests")),
    ),
    isRecorder: S.optional(S.Boolean.pipe(T.Body("is_recorder"))),
    stageAccess: S.optional(
      PresetsCreateRequestPermissionsStageAccess.pipe(T.Body("stage_access")),
    ),
    stageEnabled: S.optional(S.Boolean.pipe(T.Body("stage_enabled"))),
    transcriptionEnabled: S.optional(
      S.Boolean.pipe(T.Body("transcription_enabled")),
    ),
  }),
).annotate({
  identifier: "PresetsCreateRequestPermissions",
}) as any as S.Schema<PresetsCreateRequestPermissions>;

export type PresetsCreateRequestUiDesignTokensBorderRadius =
  | "sharp"
  | "rounded"
  | "extra-rounded"
  | "circular";
export const PresetsCreateRequestUiDesignTokensBorderRadius =
  /*@__PURE__*/ S.String;

export type PresetsCreateRequestUiDesignTokensBorderWidth =
  | "none"
  | "thin"
  | "fat";
export const PresetsCreateRequestUiDesignTokensBorderWidth =
  /*@__PURE__*/ S.String;

export interface PresetsCreateRequestUiDesignTokensColorsBackground {
  "1000": string;
  "600": string;
  "700": string;
  "800": string;
  "900": string;
}
export const PresetsCreateRequestUiDesignTokensColorsBackground =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      "1000": S.String,
      "600": S.String,
      "700": S.String,
      "800": S.String,
      "900": S.String,
    }),
  ).annotate({
    identifier: "PresetsCreateRequestUiDesignTokensColorsBackground",
  }) as any as S.Schema<PresetsCreateRequestUiDesignTokensColorsBackground>;

export interface PresetsCreateRequestUiDesignTokensColorsBrand {
  "300": string;
  "400": string;
  "500": string;
  "600": string;
  "700": string;
}
export const PresetsCreateRequestUiDesignTokensColorsBrand =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      "300": S.String,
      "400": S.String,
      "500": S.String,
      "600": S.String,
      "700": S.String,
    }),
  ).annotate({
    identifier: "PresetsCreateRequestUiDesignTokensColorsBrand",
  }) as any as S.Schema<PresetsCreateRequestUiDesignTokensColorsBrand>;

export interface PresetsCreateRequestUiDesignTokensColors {
  background: PresetsCreateRequestUiDesignTokensColorsBackground;
  brand: PresetsCreateRequestUiDesignTokensColorsBrand;
  danger: string;
  success: string;
  text: string;
  textOnBrand: string;
  videoBg: string;
  warning: string;
}
export const PresetsCreateRequestUiDesignTokensColors = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      background: PresetsCreateRequestUiDesignTokensColorsBackground,
      brand: PresetsCreateRequestUiDesignTokensColorsBrand,
      danger: S.String,
      success: S.String,
      text: S.String,
      textOnBrand: S.String.pipe(T.Body("text_on_brand")),
      videoBg: S.String.pipe(T.Body("video_bg")),
      warning: S.String,
    }),
).annotate({
  identifier: "PresetsCreateRequestUiDesignTokensColors",
}) as any as S.Schema<PresetsCreateRequestUiDesignTokensColors>;

export type PresetsCreateRequestUiDesignTokensTheme =
  | "darkest"
  | "dark"
  | "light";
export const PresetsCreateRequestUiDesignTokensTheme = /*@__PURE__*/ S.String;

export interface PresetsCreateRequestUiDesignTokens {
  borderRadius: PresetsCreateRequestUiDesignTokensBorderRadius | (string & {});
  borderWidth: PresetsCreateRequestUiDesignTokensBorderWidth | (string & {});
  colors: PresetsCreateRequestUiDesignTokensColors;
  spacingBase: number;
  theme: PresetsCreateRequestUiDesignTokensTheme | (string & {});
  fontFamily?: string;
  googleFont?: string;
  logo?: string;
}
export const PresetsCreateRequestUiDesignTokens = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    borderRadius: PresetsCreateRequestUiDesignTokensBorderRadius.pipe(
      T.Body("border_radius"),
    ),
    borderWidth: PresetsCreateRequestUiDesignTokensBorderWidth.pipe(
      T.Body("border_width"),
    ),
    colors: PresetsCreateRequestUiDesignTokensColors,
    spacingBase: S.Number.pipe(T.Body("spacing_base")),
    theme: PresetsCreateRequestUiDesignTokensTheme,
    fontFamily: S.optional(S.String.pipe(T.Body("font_family"))),
    googleFont: S.optional(S.String.pipe(T.Body("google_font"))),
    logo: S.optional(S.String),
  }),
).annotate({
  identifier: "PresetsCreateRequestUiDesignTokens",
}) as any as S.Schema<PresetsCreateRequestUiDesignTokens>;

export interface PresetsCreateRequestUi {
  designTokens: PresetsCreateRequestUiDesignTokens;
}
export const PresetsCreateRequestUi = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    designTokens: PresetsCreateRequestUiDesignTokens.pipe(
      T.Body("design_tokens"),
    ),
  }),
).annotate({
  identifier: "PresetsCreateRequestUi",
}) as any as S.Schema<PresetsCreateRequestUi>;

export interface CreatePresetRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  config: PresetsCreateRequestConfig;
  /** Name of the preset */
  name: string;
  permissions: PresetsCreateRequestPermissions;
  ui: PresetsCreateRequestUi;
}
export const CreatePresetRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    appId: S.String.pipe(T.Label("app_id")),
    config: PresetsCreateRequestConfig,
    name: S.String,
    permissions: PresetsCreateRequestPermissions,
    ui: PresetsCreateRequestUi,
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/realtime/kit/{app_id}/presets",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreatePresetRequest",
}) as any as S.Schema<CreatePresetRequest>;

export type PresetsCreateResponseDataConfigMaxVideoStreams =
  PresetsCreateRequestConfigMaxVideoStreams;
export const PresetsCreateResponseDataConfigMaxVideoStreams =
  PresetsCreateRequestConfigMaxVideoStreams;

export type PresetsCreateResponseDataConfigMediaScreenshareQuality =
  | "hd"
  | "vga"
  | "qvga"
  | "fhd"
  | "uhd";
export const PresetsCreateResponseDataConfigMediaScreenshareQuality =
  /*@__PURE__*/ S.String;

export interface PresetsCreateResponseDataConfigMediaScreenshare {
  /** Frame rate of screen share */
  frameRate: number;
  /** Quality of screen share */
  quality: PresetsCreateResponseDataConfigMediaScreenshareQuality;
}
export const PresetsCreateResponseDataConfigMediaScreenshare =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      frameRate: S.Number.pipe(T.Body("frame_rate")),
      quality: PresetsCreateResponseDataConfigMediaScreenshareQuality,
    }),
  ).annotate({
    identifier: "PresetsCreateResponseDataConfigMediaScreenshare",
  }) as any as S.Schema<PresetsCreateResponseDataConfigMediaScreenshare>;

export type PresetsCreateResponseDataConfigMediaVideoQuality =
  | "hd"
  | "vga"
  | "qvga"
  | "fhd"
  | "uhd";
export const PresetsCreateResponseDataConfigMediaVideoQuality =
  /*@__PURE__*/ S.String;

export interface PresetsCreateResponseDataConfigMediaVideo {
  /** Frame rate of participants' video */
  frameRate: number;
  /** Video quality of participants */
  quality: PresetsCreateResponseDataConfigMediaVideoQuality;
  /** Enable simulcast for participant videos. */
  simulcast?: boolean | null;
}
export const PresetsCreateResponseDataConfigMediaVideo =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      frameRate: S.Number.pipe(T.Body("frame_rate")),
      quality: PresetsCreateResponseDataConfigMediaVideoQuality,
      simulcast: S.optional(S.NullOr(S.Boolean)),
    }),
  ).annotate({
    identifier: "PresetsCreateResponseDataConfigMediaVideo",
  }) as any as S.Schema<PresetsCreateResponseDataConfigMediaVideo>;

export interface PresetsCreateResponseDataConfigMediaAudio {
  /** Enable High Quality Audio for your meetings */
  enableHighBitrate?: boolean | null;
  /** Enable Stereo for your meetings */
  enableStereo?: boolean | null;
}
export const PresetsCreateResponseDataConfigMediaAudio =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      enableHighBitrate: S.optional(
        S.NullOr(S.Boolean).pipe(T.Body("enable_high_bitrate")),
      ),
      enableStereo: S.optional(
        S.NullOr(S.Boolean).pipe(T.Body("enable_stereo")),
      ),
    }),
  ).annotate({
    identifier: "PresetsCreateResponseDataConfigMediaAudio",
  }) as any as S.Schema<PresetsCreateResponseDataConfigMediaAudio>;

export interface PresetsCreateResponseDataConfigMedia {
  /** Configuration options for participant screen shares */
  screenshare: PresetsCreateResponseDataConfigMediaScreenshare;
  /** Configuration options for participant videos */
  video: PresetsCreateResponseDataConfigMediaVideo;
  /** Control options for Audio quality. */
  audio?: PresetsCreateResponseDataConfigMediaAudio | null;
}
export const PresetsCreateResponseDataConfigMedia = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      screenshare: PresetsCreateResponseDataConfigMediaScreenshare,
      video: PresetsCreateResponseDataConfigMediaVideo,
      audio: S.optional(S.NullOr(PresetsCreateResponseDataConfigMediaAudio)),
    }),
).annotate({
  identifier: "PresetsCreateResponseDataConfigMedia",
}) as any as S.Schema<PresetsCreateResponseDataConfigMedia>;

export type PresetsCreateResponseDataConfigViewType =
  | "GROUP_CALL"
  | "WEBINAR"
  | "AUDIO_ROOM"
  | "LIVESTREAM";
export const PresetsCreateResponseDataConfigViewType = /*@__PURE__*/ S.String;

export type PresetsCreateResponseDataConfigLivestreamViewerQualitiesList =
  Array<number>;
export const PresetsCreateResponseDataConfigLivestreamViewerQualitiesList =
  /*@__PURE__*/ S.Array(
    S.Number,
  ) as any as S.Schema<PresetsCreateResponseDataConfigLivestreamViewerQualitiesList>;

export interface PresetsCreateResponseDataConfig {
  /** Maximum number of screen shares that can be active at a given time */
  maxScreenshareCount: number;
  /** Maximum number of streams that are visible on a device */
  maxVideoStreams: PresetsCreateRequestConfigMaxVideoStreams;
  /** Media configuration options. eg: Video quality */
  media: PresetsCreateResponseDataConfigMedia;
  /** Type of the meeting */
  viewType: PresetsCreateResponseDataConfigViewType;
  /** Livestream viewer quality levels. */
  livestreamViewerQualities?: PresetsCreateResponseDataConfigLivestreamViewerQualitiesList | null;
}
export const PresetsCreateResponseDataConfig = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    maxScreenshareCount: S.Number.pipe(T.Body("max_screenshare_count")),
    maxVideoStreams: PresetsCreateRequestConfigMaxVideoStreams.pipe(
      T.Body("max_video_streams"),
    ),
    media: PresetsCreateResponseDataConfigMedia,
    viewType: PresetsCreateResponseDataConfigViewType.pipe(T.Body("view_type")),
    livestreamViewerQualities: S.optional(
      S.NullOr(
        PresetsCreateResponseDataConfigLivestreamViewerQualitiesList,
      ).pipe(T.Body("livestream_viewer_qualities")),
    ),
  }),
).annotate({
  identifier: "PresetsCreateResponseDataConfig",
}) as any as S.Schema<PresetsCreateResponseDataConfig>;

export type PresetsCreateResponseDataPermissionsChatPrivate =
  PresetsCreateRequestPermissionsChatPrivate;
export const PresetsCreateResponseDataPermissionsChatPrivate =
  PresetsCreateRequestPermissionsChatPrivate;

export type PresetsCreateResponseDataPermissionsChatPublic =
  PresetsCreateRequestPermissionsChatPublic;
export const PresetsCreateResponseDataPermissionsChatPublic =
  PresetsCreateRequestPermissionsChatPublic;

export type PresetsCreateResponseDataPermissionsChat =
  PresetsCreateRequestPermissionsChat;
export const PresetsCreateResponseDataPermissionsChat =
  PresetsCreateRequestPermissionsChat;

export type PresetsCreateResponseDataPermissionsConnectedMeetings =
  PresetsCreateRequestPermissionsConnectedMeetings;
export const PresetsCreateResponseDataPermissionsConnectedMeetings =
  PresetsCreateRequestPermissionsConnectedMeetings;

export type PresetsCreateResponseDataPermissionsMediaAudioCanProduce =
  | "ALLOWED"
  | "NOT_ALLOWED"
  | "CAN_REQUEST";
export const PresetsCreateResponseDataPermissionsMediaAudioCanProduce =
  /*@__PURE__*/ S.String;

export interface PresetsCreateResponseDataPermissionsMediaAudio {
  /** Can produce audio */
  canProduce: PresetsCreateResponseDataPermissionsMediaAudioCanProduce;
}
export const PresetsCreateResponseDataPermissionsMediaAudio =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      canProduce: PresetsCreateResponseDataPermissionsMediaAudioCanProduce.pipe(
        T.Body("can_produce"),
      ),
    }),
  ).annotate({
    identifier: "PresetsCreateResponseDataPermissionsMediaAudio",
  }) as any as S.Schema<PresetsCreateResponseDataPermissionsMediaAudio>;

export type PresetsCreateResponseDataPermissionsMediaScreenshareCanProduce =
  | "ALLOWED"
  | "NOT_ALLOWED"
  | "CAN_REQUEST";
export const PresetsCreateResponseDataPermissionsMediaScreenshareCanProduce =
  /*@__PURE__*/ S.String;

export interface PresetsCreateResponseDataPermissionsMediaScreenshare {
  /** Can produce screen share video */
  canProduce: PresetsCreateResponseDataPermissionsMediaScreenshareCanProduce;
}
export const PresetsCreateResponseDataPermissionsMediaScreenshare =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      canProduce:
        PresetsCreateResponseDataPermissionsMediaScreenshareCanProduce.pipe(
          T.Body("can_produce"),
        ),
    }),
  ).annotate({
    identifier: "PresetsCreateResponseDataPermissionsMediaScreenshare",
  }) as any as S.Schema<PresetsCreateResponseDataPermissionsMediaScreenshare>;

export type PresetsCreateResponseDataPermissionsMediaVideoCanProduce =
  | "ALLOWED"
  | "NOT_ALLOWED"
  | "CAN_REQUEST";
export const PresetsCreateResponseDataPermissionsMediaVideoCanProduce =
  /*@__PURE__*/ S.String;

export interface PresetsCreateResponseDataPermissionsMediaVideo {
  /** Can produce video */
  canProduce: PresetsCreateResponseDataPermissionsMediaVideoCanProduce;
}
export const PresetsCreateResponseDataPermissionsMediaVideo =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      canProduce: PresetsCreateResponseDataPermissionsMediaVideoCanProduce.pipe(
        T.Body("can_produce"),
      ),
    }),
  ).annotate({
    identifier: "PresetsCreateResponseDataPermissionsMediaVideo",
  }) as any as S.Schema<PresetsCreateResponseDataPermissionsMediaVideo>;

export interface PresetsCreateResponseDataPermissionsMedia {
  /** Audio permissions */
  audio: PresetsCreateResponseDataPermissionsMediaAudio;
  /** Screenshare permissions */
  screenshare: PresetsCreateResponseDataPermissionsMediaScreenshare;
  /** Video permissions */
  video: PresetsCreateResponseDataPermissionsMediaVideo;
}
export const PresetsCreateResponseDataPermissionsMedia =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      audio: PresetsCreateResponseDataPermissionsMediaAudio,
      screenshare: PresetsCreateResponseDataPermissionsMediaScreenshare,
      video: PresetsCreateResponseDataPermissionsMediaVideo,
    }),
  ).annotate({
    identifier: "PresetsCreateResponseDataPermissionsMedia",
  }) as any as S.Schema<PresetsCreateResponseDataPermissionsMedia>;

export type PresetsCreateResponseDataPermissionsPlugins =
  PresetsCreateRequestPermissionsPlugins;
export const PresetsCreateResponseDataPermissionsPlugins =
  PresetsCreateRequestPermissionsPlugins;

export type PresetsCreateResponseDataPermissionsPolls =
  PresetsCreateRequestPermissionsPolls;
export const PresetsCreateResponseDataPermissionsPolls =
  PresetsCreateRequestPermissionsPolls;

export type PresetsCreateResponseDataPermissionsRecorderType =
  | "RECORDER"
  | "LIVESTREAMER"
  | "NONE";
export const PresetsCreateResponseDataPermissionsRecorderType =
  /*@__PURE__*/ S.String;

export type PresetsCreateResponseDataPermissionsWaitingRoomType =
  | "SKIP"
  | "ON_PRIVILEGED_USER_ENTRY"
  | "SKIP_ON_ACCEPT";
export const PresetsCreateResponseDataPermissionsWaitingRoomType =
  /*@__PURE__*/ S.String;

export type PresetsCreateResponseDataPermissionsStageAccess =
  | "ALLOWED"
  | "NOT_ALLOWED"
  | "CAN_REQUEST";
export const PresetsCreateResponseDataPermissionsStageAccess =
  /*@__PURE__*/ S.String;

export interface PresetsCreateResponseDataPermissions {
  /** Whether this participant can accept waiting requests */
  acceptWaitingRequests: boolean;
  canAcceptProductionRequests: boolean;
  canChangeParticipantPermissions: boolean;
  canEditDisplayName: boolean;
  canLivestream: boolean;
  canRecord: boolean;
  canSpotlight: boolean;
  chat: PresetsCreateRequestPermissionsChat;
  connectedMeetings: PresetsCreateRequestPermissionsConnectedMeetings;
  disableParticipantAudio: boolean;
  disableParticipantScreensharing: boolean;
  disableParticipantVideo: boolean;
  /** Whether this participant is visible to others or not */
  hiddenParticipant: boolean;
  kickParticipant: boolean;
  /** Media permissions */
  media: PresetsCreateResponseDataPermissionsMedia;
  pinParticipant: boolean;
  /** Plugin permissions */
  plugins: PresetsCreateRequestPermissionsPlugins;
  /** Poll permissions */
  polls: PresetsCreateRequestPermissionsPolls;
  /** Type of the recording peer */
  recorderType: PresetsCreateResponseDataPermissionsRecorderType;
  showParticipantList: boolean;
  /** Waiting room type */
  waitingRoomType: PresetsCreateResponseDataPermissionsWaitingRoomType;
  acceptStageRequests?: boolean | null;
  isRecorder?: boolean | null;
  stageAccess?: PresetsCreateResponseDataPermissionsStageAccess | null;
  stageEnabled?: boolean | null;
  transcriptionEnabled?: boolean | null;
}
export const PresetsCreateResponseDataPermissions = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      acceptWaitingRequests: S.Boolean.pipe(T.Body("accept_waiting_requests")),
      canAcceptProductionRequests: S.Boolean.pipe(
        T.Body("can_accept_production_requests"),
      ),
      canChangeParticipantPermissions: S.Boolean.pipe(
        T.Body("can_change_participant_permissions"),
      ),
      canEditDisplayName: S.Boolean.pipe(T.Body("can_edit_display_name")),
      canLivestream: S.Boolean.pipe(T.Body("can_livestream")),
      canRecord: S.Boolean.pipe(T.Body("can_record")),
      canSpotlight: S.Boolean.pipe(T.Body("can_spotlight")),
      chat: PresetsCreateRequestPermissionsChat,
      connectedMeetings: PresetsCreateRequestPermissionsConnectedMeetings.pipe(
        T.Body("connected_meetings"),
      ),
      disableParticipantAudio: S.Boolean.pipe(
        T.Body("disable_participant_audio"),
      ),
      disableParticipantScreensharing: S.Boolean.pipe(
        T.Body("disable_participant_screensharing"),
      ),
      disableParticipantVideo: S.Boolean.pipe(
        T.Body("disable_participant_video"),
      ),
      hiddenParticipant: S.Boolean.pipe(T.Body("hidden_participant")),
      kickParticipant: S.Boolean.pipe(T.Body("kick_participant")),
      media: PresetsCreateResponseDataPermissionsMedia,
      pinParticipant: S.Boolean.pipe(T.Body("pin_participant")),
      plugins: PresetsCreateRequestPermissionsPlugins,
      polls: PresetsCreateRequestPermissionsPolls,
      recorderType: PresetsCreateResponseDataPermissionsRecorderType.pipe(
        T.Body("recorder_type"),
      ),
      showParticipantList: S.Boolean.pipe(T.Body("show_participant_list")),
      waitingRoomType: PresetsCreateResponseDataPermissionsWaitingRoomType.pipe(
        T.Body("waiting_room_type"),
      ),
      acceptStageRequests: S.optional(
        S.NullOr(S.Boolean).pipe(T.Body("accept_stage_requests")),
      ),
      isRecorder: S.optional(S.NullOr(S.Boolean).pipe(T.Body("is_recorder"))),
      stageAccess: S.optional(
        S.NullOr(PresetsCreateResponseDataPermissionsStageAccess).pipe(
          T.Body("stage_access"),
        ),
      ),
      stageEnabled: S.optional(
        S.NullOr(S.Boolean).pipe(T.Body("stage_enabled")),
      ),
      transcriptionEnabled: S.optional(
        S.NullOr(S.Boolean).pipe(T.Body("transcription_enabled")),
      ),
    }),
).annotate({
  identifier: "PresetsCreateResponseDataPermissions",
}) as any as S.Schema<PresetsCreateResponseDataPermissions>;

export type PresetsCreateResponseDataUiDesignTokensBorderRadius =
  | "sharp"
  | "rounded"
  | "extra-rounded"
  | "circular";
export const PresetsCreateResponseDataUiDesignTokensBorderRadius =
  /*@__PURE__*/ S.String;

export type PresetsCreateResponseDataUiDesignTokensBorderWidth =
  | "none"
  | "thin"
  | "fat";
export const PresetsCreateResponseDataUiDesignTokensBorderWidth =
  /*@__PURE__*/ S.String;

export type PresetsCreateResponseDataUiDesignTokensColorsBackground =
  PresetsCreateRequestUiDesignTokensColorsBackground;
export const PresetsCreateResponseDataUiDesignTokensColorsBackground =
  PresetsCreateRequestUiDesignTokensColorsBackground;

export type PresetsCreateResponseDataUiDesignTokensColorsBrand =
  PresetsCreateRequestUiDesignTokensColorsBrand;
export const PresetsCreateResponseDataUiDesignTokensColorsBrand =
  PresetsCreateRequestUiDesignTokensColorsBrand;

export type PresetsCreateResponseDataUiDesignTokensColors =
  PresetsCreateRequestUiDesignTokensColors;
export const PresetsCreateResponseDataUiDesignTokensColors =
  PresetsCreateRequestUiDesignTokensColors;

export type PresetsCreateResponseDataUiDesignTokensTheme =
  | "darkest"
  | "dark"
  | "light";
export const PresetsCreateResponseDataUiDesignTokensTheme =
  /*@__PURE__*/ S.String;

export interface PresetsCreateResponseDataUiDesignTokens {
  borderRadius: PresetsCreateResponseDataUiDesignTokensBorderRadius;
  borderWidth: PresetsCreateResponseDataUiDesignTokensBorderWidth;
  colors: PresetsCreateRequestUiDesignTokensColors;
  spacingBase: number;
  theme: PresetsCreateResponseDataUiDesignTokensTheme;
  fontFamily?: string | null;
  googleFont?: string | null;
  logo?: string | null;
}
export const PresetsCreateResponseDataUiDesignTokens = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      borderRadius: PresetsCreateResponseDataUiDesignTokensBorderRadius.pipe(
        T.Body("border_radius"),
      ),
      borderWidth: PresetsCreateResponseDataUiDesignTokensBorderWidth.pipe(
        T.Body("border_width"),
      ),
      colors: PresetsCreateRequestUiDesignTokensColors,
      spacingBase: S.Number.pipe(T.Body("spacing_base")),
      theme: PresetsCreateResponseDataUiDesignTokensTheme,
      fontFamily: S.optional(S.NullOr(S.String).pipe(T.Body("font_family"))),
      googleFont: S.optional(S.NullOr(S.String).pipe(T.Body("google_font"))),
      logo: S.optional(S.NullOr(S.String)),
    }),
).annotate({
  identifier: "PresetsCreateResponseDataUiDesignTokens",
}) as any as S.Schema<PresetsCreateResponseDataUiDesignTokens>;

export interface PresetsCreateResponseDataUi {
  designTokens: PresetsCreateResponseDataUiDesignTokens;
}
export const PresetsCreateResponseDataUi = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    designTokens: PresetsCreateResponseDataUiDesignTokens.pipe(
      T.Body("design_tokens"),
    ),
  }),
).annotate({
  identifier: "PresetsCreateResponseDataUi",
}) as any as S.Schema<PresetsCreateResponseDataUi>;

export interface PresetsCreateResponseData {
  /** ID of the preset */
  id: string;
  config: PresetsCreateResponseDataConfig;
  /** Timestamp this preset was created at */
  createdAt: string;
  /** Name of the preset */
  name: string;
  permissions: PresetsCreateResponseDataPermissions;
  ui: PresetsCreateResponseDataUi;
  /** Timestamp this preset was last updated */
  updatedAt: string;
}
export const PresetsCreateResponseData = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    config: PresetsCreateResponseDataConfig,
    createdAt: S.String.pipe(T.Body("created_at")),
    name: S.String,
    permissions: PresetsCreateResponseDataPermissions,
    ui: PresetsCreateResponseDataUi,
    updatedAt: S.String.pipe(T.Body("updated_at")),
  }),
).annotate({
  identifier: "PresetsCreateResponseData",
}) as any as S.Schema<PresetsCreateResponseData>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface CreatePresetResponse {
  /** Data returned by the operation */
  data: PresetsCreateResponseData;
}
export const CreatePresetResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    data: PresetsCreateResponseData,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreatePresetResponse",
}) as any as S.Schema<CreatePresetResponse>;

export type WebhooksCreateWebhookRequestEventsItem =
  | "meeting.started"
  | "meeting.ended"
  | "meeting.participantJoined"
  | "meeting.participantLeft"
  | "meeting.chatSynced"
  | "recording.statusUpdate"
  | "livestreaming.statusUpdate"
  | "meeting.transcript"
  | "meeting.summary";
export const WebhooksCreateWebhookRequestEventsItem = /*@__PURE__*/ S.String;

export type WebhooksCreateWebhookRequestEventsList = Array<
  WebhooksCreateWebhookRequestEventsItem | (string & {})
>;
export const WebhooksCreateWebhookRequestEventsList = /*@__PURE__*/ S.Array(
  WebhooksCreateWebhookRequestEventsItem,
) as any as S.Schema<WebhooksCreateWebhookRequestEventsList>;

export interface CreateWebhookWebhookRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  /** Events that this webhook will get triggered by */
  events: WebhooksCreateWebhookRequestEventsList;
  /** Name of the webhook */
  name: string;
  /** URL this webhook will send events to */
  url: string;
  /** Set whether or not the webhook should be active when created */
  enabled?: boolean;
}
export const CreateWebhookWebhookRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    appId: S.String.pipe(T.Label("app_id")),
    events: WebhooksCreateWebhookRequestEventsList,
    name: S.String,
    url: S.String,
    enabled: S.optional(S.Boolean),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/realtime/kit/{app_id}/webhooks",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateWebhookWebhookRequest",
}) as any as S.Schema<CreateWebhookWebhookRequest>;

export type WebhooksCreateWebhookResponseDataEventsItem =
  | "meeting.started"
  | "meeting.ended"
  | "meeting.participantJoined"
  | "meeting.participantLeft"
  | "meeting.chatSynced"
  | "recording.statusUpdate"
  | "livestreaming.statusUpdate"
  | "meeting.transcript"
  | "meeting.summary";
export const WebhooksCreateWebhookResponseDataEventsItem =
  /*@__PURE__*/ S.String;

export type WebhooksCreateWebhookResponseDataEventsList =
  Array<WebhooksCreateWebhookResponseDataEventsItem>;
export const WebhooksCreateWebhookResponseDataEventsList =
  /*@__PURE__*/ S.Array(
    WebhooksCreateWebhookResponseDataEventsItem,
  ) as any as S.Schema<WebhooksCreateWebhookResponseDataEventsList>;

export interface WebhooksCreateWebhookResponseData {
  /** ID of the webhook */
  id: string;
  /** Timestamp when this webhook was created */
  createdAt: string;
  /** Set to true if the webhook is active */
  enabled: boolean;
  /** Events this webhook will send updates for */
  events: WebhooksCreateWebhookResponseDataEventsList;
  /** Name of the webhook */
  name: string;
  /** Timestamp when this webhook was updated */
  updatedAt: string;
  /** URL the webhook will send events to */
  url: string;
}
export const WebhooksCreateWebhookResponseData = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    createdAt: S.String.pipe(T.Body("created_at")),
    enabled: S.Boolean,
    events: WebhooksCreateWebhookResponseDataEventsList,
    name: S.String,
    updatedAt: S.String.pipe(T.Body("updated_at")),
    url: S.String,
  }),
).annotate({
  identifier: "WebhooksCreateWebhookResponseData",
}) as any as S.Schema<WebhooksCreateWebhookResponseData>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface CreateWebhookWebhookResponse {
  data: WebhooksCreateWebhookResponseData;
}
export const CreateWebhookWebhookResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    data: WebhooksCreateWebhookResponseData,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateWebhookWebhookResponse",
}) as any as S.Schema<CreateWebhookWebhookResponse>;

export interface DeleteMeetingParticipantMeetingRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  meetingId: string;
  participantId: string;
}
export const DeleteMeetingParticipantMeetingRequest = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      accountId: S.String.pipe(T.Label("account_id")),
      appId: S.String.pipe(T.Label("app_id")),
      meetingId: S.String.pipe(T.Label("meeting_id")),
      participantId: S.String.pipe(T.Label("participant_id")),
    })
      .pipe(
        T.Http({
          method: "DELETE",
          uri: "/accounts/{account_id}/realtime/kit/{app_id}/meetings/{meeting_id}/participants/{participant_id}",
          code: 200,
        }),
      )
      .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteMeetingParticipantMeetingRequest",
}) as any as S.Schema<DeleteMeetingParticipantMeetingRequest>;

export interface MeetingsDeleteMeetingParticipantResponseData {
  /** Timestamp this object was created at. The time is returned in ISO format. */
  createdAt: string;
  /** A unique participant ID generated by the client. */
  customParticipantId: string;
  /** ID of the preset applied to this participant. */
  presetId: string;
  /** Timestamp this object was updated at. The time is returned in ISO format. */
  updatedAt: string;
}
export const MeetingsDeleteMeetingParticipantResponseData =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      createdAt: S.String.pipe(T.Body("created_at")),
      customParticipantId: S.String.pipe(T.Body("custom_participant_id")),
      presetId: S.String.pipe(T.Body("preset_id")),
      updatedAt: S.String.pipe(T.Body("updated_at")),
    }),
  ).annotate({
    identifier: "MeetingsDeleteMeetingParticipantResponseData",
  }) as any as S.Schema<MeetingsDeleteMeetingParticipantResponseData>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface DeleteMeetingParticipantMeetingResponse {
  /** Data returned by the operation */
  data?: MeetingsDeleteMeetingParticipantResponseData | null;
}
export const DeleteMeetingParticipantMeetingResponse = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      data: S.optional(S.NullOr(MeetingsDeleteMeetingParticipantResponseData)),
    }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteMeetingParticipantMeetingResponse",
}) as any as S.Schema<DeleteMeetingParticipantMeetingResponse>;

export interface DeletePresetRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  presetId: string;
}
export const DeletePresetRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    appId: S.String.pipe(T.Label("app_id")),
    presetId: S.String.pipe(T.Label("preset_id")),
  })
    .pipe(
      T.Http({
        method: "DELETE",
        uri: "/accounts/{account_id}/realtime/kit/{app_id}/presets/{preset_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeletePresetRequest",
}) as any as S.Schema<DeletePresetRequest>;

export type PresetsDeleteResponseDataConfigMaxVideoStreams =
  PresetsCreateRequestConfigMaxVideoStreams;
export const PresetsDeleteResponseDataConfigMaxVideoStreams =
  PresetsCreateRequestConfigMaxVideoStreams;

export type PresetsDeleteResponseDataConfigMediaScreenshareQuality =
  | "hd"
  | "vga"
  | "qvga"
  | "fhd"
  | "uhd";
export const PresetsDeleteResponseDataConfigMediaScreenshareQuality =
  /*@__PURE__*/ S.String;

export interface PresetsDeleteResponseDataConfigMediaScreenshare {
  /** Frame rate of screen share */
  frameRate: number;
  /** Quality of screen share */
  quality: PresetsDeleteResponseDataConfigMediaScreenshareQuality;
}
export const PresetsDeleteResponseDataConfigMediaScreenshare =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      frameRate: S.Number.pipe(T.Body("frame_rate")),
      quality: PresetsDeleteResponseDataConfigMediaScreenshareQuality,
    }),
  ).annotate({
    identifier: "PresetsDeleteResponseDataConfigMediaScreenshare",
  }) as any as S.Schema<PresetsDeleteResponseDataConfigMediaScreenshare>;

export type PresetsDeleteResponseDataConfigMediaVideoQuality =
  | "hd"
  | "vga"
  | "qvga"
  | "fhd"
  | "uhd";
export const PresetsDeleteResponseDataConfigMediaVideoQuality =
  /*@__PURE__*/ S.String;

export interface PresetsDeleteResponseDataConfigMediaVideo {
  /** Frame rate of participants' video */
  frameRate: number;
  /** Video quality of participants */
  quality: PresetsDeleteResponseDataConfigMediaVideoQuality;
  /** Enable simulcast for participant videos. */
  simulcast?: boolean | null;
}
export const PresetsDeleteResponseDataConfigMediaVideo =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      frameRate: S.Number.pipe(T.Body("frame_rate")),
      quality: PresetsDeleteResponseDataConfigMediaVideoQuality,
      simulcast: S.optional(S.NullOr(S.Boolean)),
    }),
  ).annotate({
    identifier: "PresetsDeleteResponseDataConfigMediaVideo",
  }) as any as S.Schema<PresetsDeleteResponseDataConfigMediaVideo>;

export type PresetsDeleteResponseDataConfigMediaAudio =
  PresetsCreateResponseDataConfigMediaAudio;
export const PresetsDeleteResponseDataConfigMediaAudio =
  PresetsCreateResponseDataConfigMediaAudio;

export interface PresetsDeleteResponseDataConfigMedia {
  /** Configuration options for participant screen shares */
  screenshare: PresetsDeleteResponseDataConfigMediaScreenshare;
  /** Configuration options for participant videos */
  video: PresetsDeleteResponseDataConfigMediaVideo;
  /** Control options for Audio quality. */
  audio?: PresetsCreateResponseDataConfigMediaAudio | null;
}
export const PresetsDeleteResponseDataConfigMedia = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      screenshare: PresetsDeleteResponseDataConfigMediaScreenshare,
      video: PresetsDeleteResponseDataConfigMediaVideo,
      audio: S.optional(S.NullOr(PresetsCreateResponseDataConfigMediaAudio)),
    }),
).annotate({
  identifier: "PresetsDeleteResponseDataConfigMedia",
}) as any as S.Schema<PresetsDeleteResponseDataConfigMedia>;

export type PresetsDeleteResponseDataConfigViewType =
  | "GROUP_CALL"
  | "WEBINAR"
  | "AUDIO_ROOM"
  | "LIVESTREAM";
export const PresetsDeleteResponseDataConfigViewType = /*@__PURE__*/ S.String;

export type PresetsDeleteResponseDataConfigLivestreamViewerQualitiesList =
  Array<number>;
export const PresetsDeleteResponseDataConfigLivestreamViewerQualitiesList =
  /*@__PURE__*/ S.Array(
    S.Number,
  ) as any as S.Schema<PresetsDeleteResponseDataConfigLivestreamViewerQualitiesList>;

export interface PresetsDeleteResponseDataConfig {
  /** Maximum number of screen shares that can be active at a given time */
  maxScreenshareCount: number;
  /** Maximum number of streams that are visible on a device */
  maxVideoStreams: PresetsCreateRequestConfigMaxVideoStreams;
  /** Media configuration options. eg: Video quality */
  media: PresetsDeleteResponseDataConfigMedia;
  /** Type of the meeting */
  viewType: PresetsDeleteResponseDataConfigViewType;
  /** Livestream viewer quality levels. */
  livestreamViewerQualities?: PresetsDeleteResponseDataConfigLivestreamViewerQualitiesList | null;
}
export const PresetsDeleteResponseDataConfig = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    maxScreenshareCount: S.Number.pipe(T.Body("max_screenshare_count")),
    maxVideoStreams: PresetsCreateRequestConfigMaxVideoStreams.pipe(
      T.Body("max_video_streams"),
    ),
    media: PresetsDeleteResponseDataConfigMedia,
    viewType: PresetsDeleteResponseDataConfigViewType.pipe(T.Body("view_type")),
    livestreamViewerQualities: S.optional(
      S.NullOr(
        PresetsDeleteResponseDataConfigLivestreamViewerQualitiesList,
      ).pipe(T.Body("livestream_viewer_qualities")),
    ),
  }),
).annotate({
  identifier: "PresetsDeleteResponseDataConfig",
}) as any as S.Schema<PresetsDeleteResponseDataConfig>;

export type PresetsDeleteResponseDataPermissionsChatPrivate =
  PresetsCreateRequestPermissionsChatPrivate;
export const PresetsDeleteResponseDataPermissionsChatPrivate =
  PresetsCreateRequestPermissionsChatPrivate;

export type PresetsDeleteResponseDataPermissionsChatPublic =
  PresetsCreateRequestPermissionsChatPublic;
export const PresetsDeleteResponseDataPermissionsChatPublic =
  PresetsCreateRequestPermissionsChatPublic;

export type PresetsDeleteResponseDataPermissionsChat =
  PresetsCreateRequestPermissionsChat;
export const PresetsDeleteResponseDataPermissionsChat =
  PresetsCreateRequestPermissionsChat;

export type PresetsDeleteResponseDataPermissionsConnectedMeetings =
  PresetsCreateRequestPermissionsConnectedMeetings;
export const PresetsDeleteResponseDataPermissionsConnectedMeetings =
  PresetsCreateRequestPermissionsConnectedMeetings;

export type PresetsDeleteResponseDataPermissionsMediaAudioCanProduce =
  | "ALLOWED"
  | "NOT_ALLOWED"
  | "CAN_REQUEST";
export const PresetsDeleteResponseDataPermissionsMediaAudioCanProduce =
  /*@__PURE__*/ S.String;

export interface PresetsDeleteResponseDataPermissionsMediaAudio {
  /** Can produce audio */
  canProduce: PresetsDeleteResponseDataPermissionsMediaAudioCanProduce;
}
export const PresetsDeleteResponseDataPermissionsMediaAudio =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      canProduce: PresetsDeleteResponseDataPermissionsMediaAudioCanProduce.pipe(
        T.Body("can_produce"),
      ),
    }),
  ).annotate({
    identifier: "PresetsDeleteResponseDataPermissionsMediaAudio",
  }) as any as S.Schema<PresetsDeleteResponseDataPermissionsMediaAudio>;

export type PresetsDeleteResponseDataPermissionsMediaScreenshareCanProduce =
  | "ALLOWED"
  | "NOT_ALLOWED"
  | "CAN_REQUEST";
export const PresetsDeleteResponseDataPermissionsMediaScreenshareCanProduce =
  /*@__PURE__*/ S.String;

export interface PresetsDeleteResponseDataPermissionsMediaScreenshare {
  /** Can produce screen share video */
  canProduce: PresetsDeleteResponseDataPermissionsMediaScreenshareCanProduce;
}
export const PresetsDeleteResponseDataPermissionsMediaScreenshare =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      canProduce:
        PresetsDeleteResponseDataPermissionsMediaScreenshareCanProduce.pipe(
          T.Body("can_produce"),
        ),
    }),
  ).annotate({
    identifier: "PresetsDeleteResponseDataPermissionsMediaScreenshare",
  }) as any as S.Schema<PresetsDeleteResponseDataPermissionsMediaScreenshare>;

export type PresetsDeleteResponseDataPermissionsMediaVideoCanProduce =
  | "ALLOWED"
  | "NOT_ALLOWED"
  | "CAN_REQUEST";
export const PresetsDeleteResponseDataPermissionsMediaVideoCanProduce =
  /*@__PURE__*/ S.String;

export interface PresetsDeleteResponseDataPermissionsMediaVideo {
  /** Can produce video */
  canProduce: PresetsDeleteResponseDataPermissionsMediaVideoCanProduce;
}
export const PresetsDeleteResponseDataPermissionsMediaVideo =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      canProduce: PresetsDeleteResponseDataPermissionsMediaVideoCanProduce.pipe(
        T.Body("can_produce"),
      ),
    }),
  ).annotate({
    identifier: "PresetsDeleteResponseDataPermissionsMediaVideo",
  }) as any as S.Schema<PresetsDeleteResponseDataPermissionsMediaVideo>;

export interface PresetsDeleteResponseDataPermissionsMedia {
  /** Audio permissions */
  audio: PresetsDeleteResponseDataPermissionsMediaAudio;
  /** Screenshare permissions */
  screenshare: PresetsDeleteResponseDataPermissionsMediaScreenshare;
  /** Video permissions */
  video: PresetsDeleteResponseDataPermissionsMediaVideo;
}
export const PresetsDeleteResponseDataPermissionsMedia =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      audio: PresetsDeleteResponseDataPermissionsMediaAudio,
      screenshare: PresetsDeleteResponseDataPermissionsMediaScreenshare,
      video: PresetsDeleteResponseDataPermissionsMediaVideo,
    }),
  ).annotate({
    identifier: "PresetsDeleteResponseDataPermissionsMedia",
  }) as any as S.Schema<PresetsDeleteResponseDataPermissionsMedia>;

export type PresetsDeleteResponseDataPermissionsPlugins =
  PresetsCreateRequestPermissionsPlugins;
export const PresetsDeleteResponseDataPermissionsPlugins =
  PresetsCreateRequestPermissionsPlugins;

export type PresetsDeleteResponseDataPermissionsPolls =
  PresetsCreateRequestPermissionsPolls;
export const PresetsDeleteResponseDataPermissionsPolls =
  PresetsCreateRequestPermissionsPolls;

export type PresetsDeleteResponseDataPermissionsRecorderType =
  | "RECORDER"
  | "LIVESTREAMER"
  | "NONE";
export const PresetsDeleteResponseDataPermissionsRecorderType =
  /*@__PURE__*/ S.String;

export type PresetsDeleteResponseDataPermissionsWaitingRoomType =
  | "SKIP"
  | "ON_PRIVILEGED_USER_ENTRY"
  | "SKIP_ON_ACCEPT";
export const PresetsDeleteResponseDataPermissionsWaitingRoomType =
  /*@__PURE__*/ S.String;

export type PresetsDeleteResponseDataPermissionsStageAccess =
  | "ALLOWED"
  | "NOT_ALLOWED"
  | "CAN_REQUEST";
export const PresetsDeleteResponseDataPermissionsStageAccess =
  /*@__PURE__*/ S.String;

export interface PresetsDeleteResponseDataPermissions {
  /** Whether this participant can accept waiting requests */
  acceptWaitingRequests: boolean;
  canAcceptProductionRequests: boolean;
  canChangeParticipantPermissions: boolean;
  canEditDisplayName: boolean;
  canLivestream: boolean;
  canRecord: boolean;
  canSpotlight: boolean;
  chat: PresetsCreateRequestPermissionsChat;
  connectedMeetings: PresetsCreateRequestPermissionsConnectedMeetings;
  disableParticipantAudio: boolean;
  disableParticipantScreensharing: boolean;
  disableParticipantVideo: boolean;
  /** Whether this participant is visible to others or not */
  hiddenParticipant: boolean;
  kickParticipant: boolean;
  /** Media permissions */
  media: PresetsDeleteResponseDataPermissionsMedia;
  pinParticipant: boolean;
  /** Plugin permissions */
  plugins: PresetsCreateRequestPermissionsPlugins;
  /** Poll permissions */
  polls: PresetsCreateRequestPermissionsPolls;
  /** Type of the recording peer */
  recorderType: PresetsDeleteResponseDataPermissionsRecorderType;
  showParticipantList: boolean;
  /** Waiting room type */
  waitingRoomType: PresetsDeleteResponseDataPermissionsWaitingRoomType;
  acceptStageRequests?: boolean | null;
  isRecorder?: boolean | null;
  stageAccess?: PresetsDeleteResponseDataPermissionsStageAccess | null;
  stageEnabled?: boolean | null;
  transcriptionEnabled?: boolean | null;
}
export const PresetsDeleteResponseDataPermissions = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      acceptWaitingRequests: S.Boolean.pipe(T.Body("accept_waiting_requests")),
      canAcceptProductionRequests: S.Boolean.pipe(
        T.Body("can_accept_production_requests"),
      ),
      canChangeParticipantPermissions: S.Boolean.pipe(
        T.Body("can_change_participant_permissions"),
      ),
      canEditDisplayName: S.Boolean.pipe(T.Body("can_edit_display_name")),
      canLivestream: S.Boolean.pipe(T.Body("can_livestream")),
      canRecord: S.Boolean.pipe(T.Body("can_record")),
      canSpotlight: S.Boolean.pipe(T.Body("can_spotlight")),
      chat: PresetsCreateRequestPermissionsChat,
      connectedMeetings: PresetsCreateRequestPermissionsConnectedMeetings.pipe(
        T.Body("connected_meetings"),
      ),
      disableParticipantAudio: S.Boolean.pipe(
        T.Body("disable_participant_audio"),
      ),
      disableParticipantScreensharing: S.Boolean.pipe(
        T.Body("disable_participant_screensharing"),
      ),
      disableParticipantVideo: S.Boolean.pipe(
        T.Body("disable_participant_video"),
      ),
      hiddenParticipant: S.Boolean.pipe(T.Body("hidden_participant")),
      kickParticipant: S.Boolean.pipe(T.Body("kick_participant")),
      media: PresetsDeleteResponseDataPermissionsMedia,
      pinParticipant: S.Boolean.pipe(T.Body("pin_participant")),
      plugins: PresetsCreateRequestPermissionsPlugins,
      polls: PresetsCreateRequestPermissionsPolls,
      recorderType: PresetsDeleteResponseDataPermissionsRecorderType.pipe(
        T.Body("recorder_type"),
      ),
      showParticipantList: S.Boolean.pipe(T.Body("show_participant_list")),
      waitingRoomType: PresetsDeleteResponseDataPermissionsWaitingRoomType.pipe(
        T.Body("waiting_room_type"),
      ),
      acceptStageRequests: S.optional(
        S.NullOr(S.Boolean).pipe(T.Body("accept_stage_requests")),
      ),
      isRecorder: S.optional(S.NullOr(S.Boolean).pipe(T.Body("is_recorder"))),
      stageAccess: S.optional(
        S.NullOr(PresetsDeleteResponseDataPermissionsStageAccess).pipe(
          T.Body("stage_access"),
        ),
      ),
      stageEnabled: S.optional(
        S.NullOr(S.Boolean).pipe(T.Body("stage_enabled")),
      ),
      transcriptionEnabled: S.optional(
        S.NullOr(S.Boolean).pipe(T.Body("transcription_enabled")),
      ),
    }),
).annotate({
  identifier: "PresetsDeleteResponseDataPermissions",
}) as any as S.Schema<PresetsDeleteResponseDataPermissions>;

export type PresetsDeleteResponseDataUiDesignTokensBorderRadius =
  | "sharp"
  | "rounded"
  | "extra-rounded"
  | "circular";
export const PresetsDeleteResponseDataUiDesignTokensBorderRadius =
  /*@__PURE__*/ S.String;

export type PresetsDeleteResponseDataUiDesignTokensBorderWidth =
  | "none"
  | "thin"
  | "fat";
export const PresetsDeleteResponseDataUiDesignTokensBorderWidth =
  /*@__PURE__*/ S.String;

export type PresetsDeleteResponseDataUiDesignTokensColorsBackground =
  PresetsCreateRequestUiDesignTokensColorsBackground;
export const PresetsDeleteResponseDataUiDesignTokensColorsBackground =
  PresetsCreateRequestUiDesignTokensColorsBackground;

export type PresetsDeleteResponseDataUiDesignTokensColorsBrand =
  PresetsCreateRequestUiDesignTokensColorsBrand;
export const PresetsDeleteResponseDataUiDesignTokensColorsBrand =
  PresetsCreateRequestUiDesignTokensColorsBrand;

export type PresetsDeleteResponseDataUiDesignTokensColors =
  PresetsCreateRequestUiDesignTokensColors;
export const PresetsDeleteResponseDataUiDesignTokensColors =
  PresetsCreateRequestUiDesignTokensColors;

export type PresetsDeleteResponseDataUiDesignTokensTheme =
  | "darkest"
  | "dark"
  | "light";
export const PresetsDeleteResponseDataUiDesignTokensTheme =
  /*@__PURE__*/ S.String;

export interface PresetsDeleteResponseDataUiDesignTokens {
  borderRadius: PresetsDeleteResponseDataUiDesignTokensBorderRadius;
  borderWidth: PresetsDeleteResponseDataUiDesignTokensBorderWidth;
  colors: PresetsCreateRequestUiDesignTokensColors;
  spacingBase: number;
  theme: PresetsDeleteResponseDataUiDesignTokensTheme;
  fontFamily?: string | null;
  googleFont?: string | null;
  logo?: string | null;
}
export const PresetsDeleteResponseDataUiDesignTokens = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      borderRadius: PresetsDeleteResponseDataUiDesignTokensBorderRadius.pipe(
        T.Body("border_radius"),
      ),
      borderWidth: PresetsDeleteResponseDataUiDesignTokensBorderWidth.pipe(
        T.Body("border_width"),
      ),
      colors: PresetsCreateRequestUiDesignTokensColors,
      spacingBase: S.Number.pipe(T.Body("spacing_base")),
      theme: PresetsDeleteResponseDataUiDesignTokensTheme,
      fontFamily: S.optional(S.NullOr(S.String).pipe(T.Body("font_family"))),
      googleFont: S.optional(S.NullOr(S.String).pipe(T.Body("google_font"))),
      logo: S.optional(S.NullOr(S.String)),
    }),
).annotate({
  identifier: "PresetsDeleteResponseDataUiDesignTokens",
}) as any as S.Schema<PresetsDeleteResponseDataUiDesignTokens>;

export interface PresetsDeleteResponseDataUi {
  designTokens: PresetsDeleteResponseDataUiDesignTokens;
}
export const PresetsDeleteResponseDataUi = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    designTokens: PresetsDeleteResponseDataUiDesignTokens.pipe(
      T.Body("design_tokens"),
    ),
  }),
).annotate({
  identifier: "PresetsDeleteResponseDataUi",
}) as any as S.Schema<PresetsDeleteResponseDataUi>;

export interface PresetsDeleteResponseData {
  /** ID of the preset */
  id: string;
  config: PresetsDeleteResponseDataConfig;
  /** Timestamp this preset was created at */
  createdAt: string;
  /** Name of the preset */
  name: string;
  permissions: PresetsDeleteResponseDataPermissions;
  ui: PresetsDeleteResponseDataUi;
  /** Timestamp this preset was last updated */
  updatedAt: string;
}
export const PresetsDeleteResponseData = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    config: PresetsDeleteResponseDataConfig,
    createdAt: S.String.pipe(T.Body("created_at")),
    name: S.String,
    permissions: PresetsDeleteResponseDataPermissions,
    ui: PresetsDeleteResponseDataUi,
    updatedAt: S.String.pipe(T.Body("updated_at")),
  }),
).annotate({
  identifier: "PresetsDeleteResponseData",
}) as any as S.Schema<PresetsDeleteResponseData>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface DeletePresetResponse {
  /** Data returned by the operation */
  data: PresetsDeleteResponseData;
}
export const DeletePresetResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    data: PresetsDeleteResponseData,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeletePresetResponse",
}) as any as S.Schema<DeletePresetResponse>;

export interface DeleteWebhookWebhookRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  webhookId: string;
}
export const DeleteWebhookWebhookRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    appId: S.String.pipe(T.Label("app_id")),
    webhookId: S.String.pipe(T.Label("webhook_id")),
  })
    .pipe(
      T.Http({
        method: "DELETE",
        uri: "/accounts/{account_id}/realtime/kit/{app_id}/webhooks/{webhook_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteWebhookWebhookRequest",
}) as any as S.Schema<DeleteWebhookWebhookRequest>;

export type WebhooksDeleteWebhookResponseDataEventsItem =
  | "meeting.started"
  | "meeting.ended"
  | "meeting.participantJoined"
  | "meeting.participantLeft"
  | "meeting.chatSynced"
  | "recording.statusUpdate"
  | "livestreaming.statusUpdate"
  | "meeting.transcript"
  | "meeting.summary";
export const WebhooksDeleteWebhookResponseDataEventsItem =
  /*@__PURE__*/ S.String;

export type WebhooksDeleteWebhookResponseDataEventsList =
  Array<WebhooksDeleteWebhookResponseDataEventsItem>;
export const WebhooksDeleteWebhookResponseDataEventsList =
  /*@__PURE__*/ S.Array(
    WebhooksDeleteWebhookResponseDataEventsItem,
  ) as any as S.Schema<WebhooksDeleteWebhookResponseDataEventsList>;

export interface WebhooksDeleteWebhookResponseData {
  /** ID of the webhook */
  id: string;
  /** Timestamp when this webhook was created */
  createdAt: string;
  /** Set to true if the webhook is active */
  enabled: boolean;
  /** Events this webhook will send updates for */
  events: WebhooksDeleteWebhookResponseDataEventsList;
  /** Name of the webhook */
  name: string;
  /** Timestamp when this webhook was updated */
  updatedAt: string;
  /** URL the webhook will send events to */
  url: string;
}
export const WebhooksDeleteWebhookResponseData = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    createdAt: S.String.pipe(T.Body("created_at")),
    enabled: S.Boolean,
    events: WebhooksDeleteWebhookResponseDataEventsList,
    name: S.String,
    updatedAt: S.String.pipe(T.Body("updated_at")),
    url: S.String,
  }),
).annotate({
  identifier: "WebhooksDeleteWebhookResponseData",
}) as any as S.Schema<WebhooksDeleteWebhookResponseData>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface DeleteWebhookWebhookResponse {
  data: WebhooksDeleteWebhookResponseData;
}
export const DeleteWebhookWebhookResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    data: WebhooksDeleteWebhookResponseData,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteWebhookWebhookResponse",
}) as any as S.Schema<DeleteWebhookWebhookResponse>;

export interface EditParticipantMeetingRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  meetingId: string;
  participantId: string;
  /** (Optional) Name of the participant. */
  name?: string;
  /** (Optional) A URL to a picture to be used for the participant. */
  picture?: string;
  /** (Optional) Name of the preset to apply to this participant. */
  presetName?: string;
}
export const EditParticipantMeetingRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    appId: S.String.pipe(T.Label("app_id")),
    meetingId: S.String.pipe(T.Label("meeting_id")),
    participantId: S.String.pipe(T.Label("participant_id")),
    name: S.optional(S.String),
    picture: S.optional(S.String),
    presetName: S.optional(S.String.pipe(T.Body("preset_name"))),
  })
    .pipe(
      T.Http({
        method: "PATCH",
        uri: "/accounts/{account_id}/realtime/kit/{app_id}/meetings/{meeting_id}/participants/{participant_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "EditParticipantMeetingRequest",
}) as any as S.Schema<EditParticipantMeetingRequest>;

export type MeetingsEditParticipantResponseData =
  MeetingsAddParticipantResponseData;
export const MeetingsEditParticipantResponseData =
  MeetingsAddParticipantResponseData;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface EditParticipantMeetingResponse {
  /** Represents a participant. */
  data?: MeetingsAddParticipantResponseData | null;
}
export const EditParticipantMeetingResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    data: S.optional(S.NullOr(MeetingsAddParticipantResponseData)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "EditParticipantMeetingResponse",
}) as any as S.Schema<EditParticipantMeetingResponse>;

export type WebhooksEditWebhookRequestEventsItem =
  | "meeting.started"
  | "meeting.ended"
  | "meeting.participantJoined"
  | "meeting.participantLeft"
  | "recording.statusUpdate"
  | "livestreaming.statusUpdate"
  | "meeting.chatSynced"
  | "meeting.transcript"
  | "meeting.summary";
export const WebhooksEditWebhookRequestEventsItem = /*@__PURE__*/ S.String;

export type WebhooksEditWebhookRequestEventsList = Array<
  WebhooksEditWebhookRequestEventsItem | (string & {})
>;
export const WebhooksEditWebhookRequestEventsList = /*@__PURE__*/ S.Array(
  WebhooksEditWebhookRequestEventsItem,
) as any as S.Schema<WebhooksEditWebhookRequestEventsList>;

export interface EditWebhookWebhookRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  webhookId: string;
  enabled?: boolean;
  /** Events that the webhook will get triggered by */
  events?: WebhooksEditWebhookRequestEventsList;
  /** Name of the webhook */
  name?: string;
  /** URL the webhook will send events to */
  url?: string;
}
export const EditWebhookWebhookRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    appId: S.String.pipe(T.Label("app_id")),
    webhookId: S.String.pipe(T.Label("webhook_id")),
    enabled: S.optional(S.Boolean),
    events: S.optional(WebhooksEditWebhookRequestEventsList),
    name: S.optional(S.String),
    url: S.optional(S.String),
  })
    .pipe(
      T.Http({
        method: "PATCH",
        uri: "/accounts/{account_id}/realtime/kit/{app_id}/webhooks/{webhook_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "EditWebhookWebhookRequest",
}) as any as S.Schema<EditWebhookWebhookRequest>;

export type WebhooksEditWebhookResponseDataEventsItem =
  | "meeting.started"
  | "meeting.ended"
  | "meeting.participantJoined"
  | "meeting.participantLeft"
  | "meeting.chatSynced"
  | "recording.statusUpdate"
  | "livestreaming.statusUpdate"
  | "meeting.transcript"
  | "meeting.summary";
export const WebhooksEditWebhookResponseDataEventsItem = /*@__PURE__*/ S.String;

export type WebhooksEditWebhookResponseDataEventsList =
  Array<WebhooksEditWebhookResponseDataEventsItem>;
export const WebhooksEditWebhookResponseDataEventsList = /*@__PURE__*/ S.Array(
  WebhooksEditWebhookResponseDataEventsItem,
) as any as S.Schema<WebhooksEditWebhookResponseDataEventsList>;

export interface WebhooksEditWebhookResponseData {
  /** ID of the webhook */
  id: string;
  /** Timestamp when this webhook was created */
  createdAt: string;
  /** Set to true if the webhook is active */
  enabled: boolean;
  /** Events this webhook will send updates for */
  events: WebhooksEditWebhookResponseDataEventsList;
  /** Name of the webhook */
  name: string;
  /** Timestamp when this webhook was updated */
  updatedAt: string;
  /** URL the webhook will send events to */
  url: string;
}
export const WebhooksEditWebhookResponseData = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    createdAt: S.String.pipe(T.Body("created_at")),
    enabled: S.Boolean,
    events: WebhooksEditWebhookResponseDataEventsList,
    name: S.String,
    updatedAt: S.String.pipe(T.Body("updated_at")),
    url: S.String,
  }),
).annotate({
  identifier: "WebhooksEditWebhookResponseData",
}) as any as S.Schema<WebhooksEditWebhookResponseData>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface EditWebhookWebhookResponse {
  data: WebhooksEditWebhookResponseData;
}
export const EditWebhookWebhookResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    data: WebhooksEditWebhookResponseData,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "EditWebhookWebhookResponse",
}) as any as S.Schema<EditWebhookWebhookResponse>;

export interface GenerateSummaryOfTranscriptsSessionRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  sessionId: string;
}
export const GenerateSummaryOfTranscriptsSessionRequest =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      accountId: S.String.pipe(T.Label("account_id")),
      appId: S.String.pipe(T.Label("app_id")),
      sessionId: S.String.pipe(T.Label("session_id")),
    })
      .pipe(
        T.Http({
          method: "POST",
          uri: "/accounts/{account_id}/realtime/kit/{app_id}/sessions/{session_id}/summary",
          code: 200,
        }),
      )
      .pipe(T.KeyDictionary(KEY_DICTIONARY)),
  ).annotate({
    identifier: "GenerateSummaryOfTranscriptsSessionRequest",
  }) as any as S.Schema<GenerateSummaryOfTranscriptsSessionRequest>;

export interface SessionsGenerateSummaryOfTranscriptsResponseData {
  sessionId?: string | null;
  status?: string | null;
}
export const SessionsGenerateSummaryOfTranscriptsResponseData =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      sessionId: S.optional(S.NullOr(S.String).pipe(T.Body("session_id"))),
      status: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier: "SessionsGenerateSummaryOfTranscriptsResponseData",
  }) as any as S.Schema<SessionsGenerateSummaryOfTranscriptsResponseData>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface GenerateSummaryOfTranscriptsSessionResponse {
  data?: SessionsGenerateSummaryOfTranscriptsResponseData | null;
}
export const GenerateSummaryOfTranscriptsSessionResponse =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      data: S.optional(
        S.NullOr(SessionsGenerateSummaryOfTranscriptsResponseData),
      ),
    }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
  ).annotate({
    identifier: "GenerateSummaryOfTranscriptsSessionResponse",
  }) as any as S.Schema<GenerateSummaryOfTranscriptsSessionResponse>;

export interface GetActiveLivestreamsForLivestreamIdLivestreamRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  livestreamId: string;
}
export const GetActiveLivestreamsForLivestreamIdLivestreamRequest =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      accountId: S.String.pipe(T.Label("account_id")),
      appId: S.String.pipe(T.Label("app_id")),
      livestreamId: S.String.pipe(T.Label("livestream_id")),
    })
      .pipe(
        T.Http({
          method: "GET",
          uri: "/accounts/{account_id}/realtime/kit/{app_id}/livestreams/{livestream_id}/active-livestream-session",
          code: 200,
        }),
      )
      .pipe(T.KeyDictionary(KEY_DICTIONARY)),
  ).annotate({
    identifier: "GetActiveLivestreamsForLivestreamIdLivestreamRequest",
  }) as any as S.Schema<GetActiveLivestreamsForLivestreamIdLivestreamRequest>;

export type LivestreamsGetActiveLivestreamsForLivestreamIdResponseDataLivestreamStatus =
  | "LIVE"
  | "IDLE"
  | "ERRORED"
  | "INVOKED";
export const LivestreamsGetActiveLivestreamsForLivestreamIdResponseDataLivestreamStatus =
  /*@__PURE__*/ S.String;

export interface LivestreamsGetActiveLivestreamsForLivestreamIdResponseDataLivestream {
  id?: string | null;
  /** Timestamp the object was created at. The time is returned in ISO format. */
  createdAt?: string | null;
  /** Specifies if the livestream was disabled. */
  disabled?: string | null;
  /** The server URL to which the RTMP encoder sends the video and audio data. */
  ingestServer?: string | null;
  /** ID of the meeting. */
  meetingId?: string | null;
  /** Name of the livestream. */
  name?: string | null;
  /** The web address that viewers can use to watch the livestream. */
  playbackUrl?: string | null;
  status?: LivestreamsGetActiveLivestreamsForLivestreamIdResponseDataLivestreamStatus | null;
  /** Unique key for accessing each livestream. */
  streamKey?: string | null;
  /** Timestamp the object was updated at. The time is returned in ISO format. */
  updatedAt?: string | null;
}
export const LivestreamsGetActiveLivestreamsForLivestreamIdResponseDataLivestream =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.optional(S.NullOr(S.String)),
      createdAt: S.optional(S.NullOr(S.String).pipe(T.Body("created_at"))),
      disabled: S.optional(S.NullOr(S.String)),
      ingestServer: S.optional(
        S.NullOr(S.String).pipe(T.Body("ingest_server")),
      ),
      meetingId: S.optional(S.NullOr(S.String).pipe(T.Body("meeting_id"))),
      name: S.optional(S.NullOr(S.String)),
      playbackUrl: S.optional(S.NullOr(S.String).pipe(T.Body("playback_url"))),
      status: S.optional(
        S.NullOr(
          LivestreamsGetActiveLivestreamsForLivestreamIdResponseDataLivestreamStatus,
        ),
      ),
      streamKey: S.optional(S.NullOr(S.String).pipe(T.Body("stream_key"))),
      updatedAt: S.optional(S.NullOr(S.String).pipe(T.Body("updated_at"))),
    }),
  ).annotate({
    identifier:
      "LivestreamsGetActiveLivestreamsForLivestreamIdResponseDataLivestream",
  }) as any as S.Schema<LivestreamsGetActiveLivestreamsForLivestreamIdResponseDataLivestream>;

export interface LivestreamsGetActiveLivestreamsForLivestreamIdResponseDataSession {
  id?: string | null;
  /** Timestamp the object was created at. The time is returned in ISO format. */
  createdAt?: string | null;
  errMessage?: string | null;
  /** The time duration for which the input was given or the meeting was streamed. */
  ingestSeconds?: string | null;
  /** Timestamp the object was invoked. The time is returned in ISO format. */
  invokedTime?: string | null;
  livestreamId?: string | null;
  /** Timestamp the object was started. The time is returned in ISO format. */
  startedTime?: string | null;
  /** Timestamp the object was stopped. The time is returned in ISO format. */
  stoppedTime?: string | null;
  /** Timestamp the object was updated at. The time is returned in ISO format. */
  updatedAt?: string | null;
  /** The total view time for which the viewers watched the stream. */
  viewerSeconds?: string | null;
}
export const LivestreamsGetActiveLivestreamsForLivestreamIdResponseDataSession =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.optional(S.NullOr(S.String)),
      createdAt: S.optional(S.NullOr(S.String).pipe(T.Body("created_at"))),
      errMessage: S.optional(S.NullOr(S.String).pipe(T.Body("err_message"))),
      ingestSeconds: S.optional(
        S.NullOr(S.String).pipe(T.Body("ingest_seconds")),
      ),
      invokedTime: S.optional(S.NullOr(S.String).pipe(T.Body("invoked_time"))),
      livestreamId: S.optional(
        S.NullOr(S.String).pipe(T.Body("livestream_id")),
      ),
      startedTime: S.optional(S.NullOr(S.String).pipe(T.Body("started_time"))),
      stoppedTime: S.optional(S.NullOr(S.String).pipe(T.Body("stopped_time"))),
      updatedAt: S.optional(S.NullOr(S.String).pipe(T.Body("updated_at"))),
      viewerSeconds: S.optional(
        S.NullOr(S.String).pipe(T.Body("viewer_seconds")),
      ),
    }),
  ).annotate({
    identifier:
      "LivestreamsGetActiveLivestreamsForLivestreamIdResponseDataSession",
  }) as any as S.Schema<LivestreamsGetActiveLivestreamsForLivestreamIdResponseDataSession>;

export interface LivestreamsGetActiveLivestreamsForLivestreamIdResponseData {
  livestream?: LivestreamsGetActiveLivestreamsForLivestreamIdResponseDataLivestream | null;
  session?: LivestreamsGetActiveLivestreamsForLivestreamIdResponseDataSession | null;
}
export const LivestreamsGetActiveLivestreamsForLivestreamIdResponseData =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      livestream: S.optional(
        S.NullOr(
          LivestreamsGetActiveLivestreamsForLivestreamIdResponseDataLivestream,
        ),
      ),
      session: S.optional(
        S.NullOr(
          LivestreamsGetActiveLivestreamsForLivestreamIdResponseDataSession,
        ),
      ),
    }),
  ).annotate({
    identifier: "LivestreamsGetActiveLivestreamsForLivestreamIdResponseData",
  }) as any as S.Schema<LivestreamsGetActiveLivestreamsForLivestreamIdResponseData>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface GetActiveLivestreamsForLivestreamIdLivestreamResponse {
  data?: LivestreamsGetActiveLivestreamsForLivestreamIdResponseData | null;
}
export const GetActiveLivestreamsForLivestreamIdLivestreamResponse =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      data: S.optional(
        S.NullOr(LivestreamsGetActiveLivestreamsForLivestreamIdResponseData),
      ),
    }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
  ).annotate({
    identifier: "GetActiveLivestreamsForLivestreamIdLivestreamResponse",
  }) as any as S.Schema<GetActiveLivestreamsForLivestreamIdLivestreamResponse>;

export interface GetActiveRecordingsRecordingRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  meetingId: string;
}
export const GetActiveRecordingsRecordingRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    appId: S.String.pipe(T.Label("app_id")),
    meetingId: S.String.pipe(T.Label("meeting_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/realtime/kit/{app_id}/recordings/active-recording/{meeting_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetActiveRecordingsRecordingRequest",
}) as any as S.Schema<GetActiveRecordingsRecordingRequest>;

export type RecordingsGetActiveRecordingsResponseDataStatus =
  | "INVOKED"
  | "RECORDING"
  | "UPLOADING"
  | "UPLOADED"
  | "ERRORED"
  | "PAUSED";
export const RecordingsGetActiveRecordingsResponseDataStatus =
  /*@__PURE__*/ S.String;

export interface RecordingsGetActiveRecordingsResponseData {
  /** ID of the recording */
  id: string;
  /** If the audio_config is passed, the URL for downloading the audio recording is returned. */
  audioDownloadUrl: string;
  /** URL where the recording can be downloaded. */
  downloadUrl: string;
  /** Timestamp when the download URL expires. */
  downloadUrlExpiry: string;
  /** File size of the recording, in bytes. */
  fileSize: number;
  /** Timestamp when this recording was invoked. */
  invokedTime: string;
  /** File name of the recording. */
  outputFileName: string;
  /** ID of the meeting session this recording is for. */
  sessionId: string;
  /** Timestamp when this recording actually started after being invoked. Usually a few seconds after `invoked_time`. */
  startedTime: string;
  /** Current status of the recording. */
  status: RecordingsGetActiveRecordingsResponseDataStatus;
  /** Timestamp when this recording was stopped. Optional; is present only when the recording has actually been stopped. */
  stoppedTime: string;
  /** Total recording time in seconds. */
  recordingDuration?: number | null;
}
export const RecordingsGetActiveRecordingsResponseData =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      audioDownloadUrl: S.String.pipe(T.Body("audio_download_url")),
      downloadUrl: S.String.pipe(T.Body("download_url")),
      downloadUrlExpiry: S.String.pipe(T.Body("download_url_expiry")),
      fileSize: S.Number.pipe(T.Body("file_size")),
      invokedTime: S.String.pipe(T.Body("invoked_time")),
      outputFileName: S.String.pipe(T.Body("output_file_name")),
      sessionId: S.String.pipe(T.Body("session_id")),
      startedTime: S.String.pipe(T.Body("started_time")),
      status: RecordingsGetActiveRecordingsResponseDataStatus,
      stoppedTime: S.String.pipe(T.Body("stopped_time")),
      recordingDuration: S.optional(
        S.NullOr(S.Number).pipe(T.Body("recording_duration")),
      ),
    }),
  ).annotate({
    identifier: "RecordingsGetActiveRecordingsResponseData",
  }) as any as S.Schema<RecordingsGetActiveRecordingsResponseData>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface GetActiveRecordingsRecordingResponse {
  /** Data returned by the operation */
  data: RecordingsGetActiveRecordingsResponseData;
}
export const GetActiveRecordingsRecordingResponse = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      data: RecordingsGetActiveRecordingsResponseData,
    }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetActiveRecordingsRecordingResponse",
}) as any as S.Schema<GetActiveRecordingsRecordingResponse>;

export interface GetActiveSessionActiveSessionRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  meetingId: string;
}
export const GetActiveSessionActiveSessionRequest = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      accountId: S.String.pipe(T.Label("account_id")),
      appId: S.String.pipe(T.Label("app_id")),
      meetingId: S.String.pipe(T.Label("meeting_id")),
    })
      .pipe(
        T.Http({
          method: "GET",
          uri: "/accounts/{account_id}/realtime/kit/{app_id}/meetings/{meeting_id}/active-session",
          code: 200,
        }),
      )
      .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetActiveSessionActiveSessionRequest",
}) as any as S.Schema<GetActiveSessionActiveSessionRequest>;

export type ActiveSessionGetActiveSessionResponseDataStatus = "LIVE" | "ENDED";
export const ActiveSessionGetActiveSessionResponseDataStatus =
  /*@__PURE__*/ S.String;

export type ActiveSessionGetActiveSessionResponseDataType =
  | "meeting"
  | "livestream"
  | "participant";
export const ActiveSessionGetActiveSessionResponseDataType =
  /*@__PURE__*/ S.String;

export type ActiveSessionGetActiveSessionResponseDataBreakoutRoomsList =
  Array<unknown>;
export const ActiveSessionGetActiveSessionResponseDataBreakoutRoomsList =
  /*@__PURE__*/ S.Array(
    S.Unknown,
  ) as any as S.Schema<ActiveSessionGetActiveSessionResponseDataBreakoutRoomsList>;

export interface ActiveSessionGetActiveSessionResponseData {
  /** ID of the session */
  id: string;
  /** ID of the meeting this session is associated with. In the case of V2 meetings, it is always a UUID. In V1 meetings, it is a room name of the form `abcdef-ghijkl` */
  associatedId: string;
  /** timestamp when session created */
  createdAt: string;
  /** number of participants currently in the session */
  liveParticipants: number;
  /** number of maximum participants that were in the session */
  maxConcurrentParticipants: number;
  /** Title of the meeting this session belongs to */
  meetingDisplayName: string;
  /** number of minutes consumed since the session started */
  minutesConsumed: number;
  /** App id that hosted this session */
  organizationId: string;
  /** timestamp when session started */
  startedAt: string;
  /** current status of session */
  status: ActiveSessionGetActiveSessionResponseDataStatus;
  /** type of session */
  type: ActiveSessionGetActiveSessionResponseDataType;
  /** timestamp when session was last updated */
  updatedAt: string;
  breakoutRooms?: ActiveSessionGetActiveSessionResponseDataBreakoutRoomsList | null;
  /** timestamp when session ended */
  endedAt?: string | null;
}
export const ActiveSessionGetActiveSessionResponseData =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      associatedId: S.String.pipe(T.Body("associated_id")),
      createdAt: S.String.pipe(T.Body("created_at")),
      liveParticipants: S.Number.pipe(T.Body("live_participants")),
      maxConcurrentParticipants: S.Number.pipe(
        T.Body("max_concurrent_participants"),
      ),
      meetingDisplayName: S.String.pipe(T.Body("meeting_display_name")),
      minutesConsumed: S.Number.pipe(T.Body("minutes_consumed")),
      organizationId: S.String.pipe(T.Body("organization_id")),
      startedAt: S.String.pipe(T.Body("started_at")),
      status: ActiveSessionGetActiveSessionResponseDataStatus,
      type: ActiveSessionGetActiveSessionResponseDataType,
      updatedAt: S.String.pipe(T.Body("updated_at")),
      breakoutRooms: S.optional(
        S.NullOr(
          ActiveSessionGetActiveSessionResponseDataBreakoutRoomsList,
        ).pipe(T.Body("breakout_rooms")),
      ),
      endedAt: S.optional(S.NullOr(S.String).pipe(T.Body("ended_at"))),
    }),
  ).annotate({
    identifier: "ActiveSessionGetActiveSessionResponseData",
  }) as any as S.Schema<ActiveSessionGetActiveSessionResponseData>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface GetActiveSessionActiveSessionResponse {
  data?: ActiveSessionGetActiveSessionResponseData | null;
}
export const GetActiveSessionActiveSessionResponse = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      data: S.optional(S.NullOr(ActiveSessionGetActiveSessionResponseData)),
    }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetActiveSessionActiveSessionResponse",
}) as any as S.Schema<GetActiveSessionActiveSessionResponse>;

export type LivestreamsGetAllLivestreamsRequestSortOrder = "ASC" | "DSC";
export const LivestreamsGetAllLivestreamsRequestSortOrder =
  /*@__PURE__*/ S.String;

export type LivestreamsGetAllLivestreamsRequestStatus =
  | "LIVE"
  | "IDLE"
  | "ERRORED"
  | "INVOKED";
export const LivestreamsGetAllLivestreamsRequestStatus = /*@__PURE__*/ S.String;

export interface GetAllLivestreamsLivestreamRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  /** Specify the end time range in ISO format to access the live stream. */
  endTime?: string;
  /** Exclude the RealtimeKit meetings that are livestreamed. */
  excludeMeetings?: boolean;
  /** The page number from which you want your page search results to be displayed. */
  pageNo?: number;
  /** Number of results per page. */
  perPage?: number;
  /** Specifies the sorting order for the results. */
  sortOrder?: LivestreamsGetAllLivestreamsRequestSortOrder | (string & {});
  /** Specify the start time range in ISO format to access the live stream. */
  startTime?: string;
  /** Specifies the status of the operation. */
  status?: LivestreamsGetAllLivestreamsRequestStatus | (string & {});
}
export const GetAllLivestreamsLivestreamRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    appId: S.String.pipe(T.Label("app_id")),
    endTime: S.optional(S.String.pipe(T.Query("end_time"))),
    excludeMeetings: S.optional(S.Boolean.pipe(T.Query("exclude_meetings"))),
    pageNo: S.optional(S.Number.pipe(T.Query("page_no"))),
    perPage: S.optional(S.Number.pipe(T.Query("per_page"))),
    sortOrder: S.optional(
      LivestreamsGetAllLivestreamsRequestSortOrder.pipe(T.Query("sort_order")),
    ),
    startTime: S.optional(S.String.pipe(T.Query("start_time"))),
    status: S.optional(
      LivestreamsGetAllLivestreamsRequestStatus.pipe(T.Query()),
    ),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/realtime/kit/{app_id}/livestreams",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetAllLivestreamsLivestreamRequest",
}) as any as S.Schema<GetAllLivestreamsLivestreamRequest>;

export interface LivestreamsGetAllLivestreamsResponseDataPaging {
  endOffset?: number | null;
  startOffset?: number | null;
  totalCount?: number | null;
}
export const LivestreamsGetAllLivestreamsResponseDataPaging =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      endOffset: S.optional(S.NullOr(S.Number).pipe(T.Body("end_offset"))),
      startOffset: S.optional(S.NullOr(S.Number).pipe(T.Body("start_offset"))),
      totalCount: S.optional(S.NullOr(S.Number).pipe(T.Body("total_count"))),
    }),
  ).annotate({
    identifier: "LivestreamsGetAllLivestreamsResponseDataPaging",
  }) as any as S.Schema<LivestreamsGetAllLivestreamsResponseDataPaging>;

export type LivestreamsGetAllLivestreamsResponseDataStatus =
  | "LIVE"
  | "IDLE"
  | "ERRORED"
  | "INVOKED";
export const LivestreamsGetAllLivestreamsResponseDataStatus =
  /*@__PURE__*/ S.String;

export interface LivestreamsGetAllLivestreamsResponseData {
  /** The ID of the livestream. */
  id?: string | null;
  /** Timestamp the object was created at. The time is returned in ISO format. */
  createdAt?: string | null;
  /** Specifies if the livestream was disabled. */
  disabled?: string | null;
  /** The server URL to which the RTMP encoder sends the video and audio data. */
  ingestServer?: string | null;
  /** ID of the meeting. */
  meetingId?: string | null;
  /** Name of the livestream. */
  name?: string | null;
  paging?: LivestreamsGetAllLivestreamsResponseDataPaging | null;
  /** The web address that viewers can use to watch the livestream. */
  playbackUrl?: string | null;
  status?: LivestreamsGetAllLivestreamsResponseDataStatus | null;
  /** Unique key for accessing each livestream. */
  streamKey?: string | null;
  /** Timestamp the object was updated at. The time is returned in ISO format. */
  updatedAt?: string | null;
}
export const LivestreamsGetAllLivestreamsResponseData = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.optional(S.NullOr(S.String)),
      createdAt: S.optional(S.NullOr(S.String).pipe(T.Body("created_at"))),
      disabled: S.optional(S.NullOr(S.String)),
      ingestServer: S.optional(
        S.NullOr(S.String).pipe(T.Body("ingest_server")),
      ),
      meetingId: S.optional(S.NullOr(S.String).pipe(T.Body("meeting_id"))),
      name: S.optional(S.NullOr(S.String)),
      paging: S.optional(
        S.NullOr(LivestreamsGetAllLivestreamsResponseDataPaging),
      ),
      playbackUrl: S.optional(S.NullOr(S.String).pipe(T.Body("playback_url"))),
      status: S.optional(
        S.NullOr(LivestreamsGetAllLivestreamsResponseDataStatus),
      ),
      streamKey: S.optional(S.NullOr(S.String).pipe(T.Body("stream_key"))),
      updatedAt: S.optional(S.NullOr(S.String).pipe(T.Body("updated_at"))),
    }),
).annotate({
  identifier: "LivestreamsGetAllLivestreamsResponseData",
}) as any as S.Schema<LivestreamsGetAllLivestreamsResponseData>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface GetAllLivestreamsLivestreamResponse {
  data?: LivestreamsGetAllLivestreamsResponseData | null;
}
export const GetAllLivestreamsLivestreamResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    data: S.optional(S.NullOr(LivestreamsGetAllLivestreamsResponseData)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetAllLivestreamsLivestreamResponse",
}) as any as S.Schema<GetAllLivestreamsLivestreamResponse>;

export type AppsGetRequestSortOrder = "ASC" | "DESC";
export const AppsGetRequestSortOrder = /*@__PURE__*/ S.String;

export interface GetAppRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The page number from which you want your page search results to be displayed. */
  pageNo?: number;
  /** Number of results per page. */
  perPage?: number;
  /** Search string that matches apps by name. */
  search?: string;
  /** Sort order for apps by creation time. */
  sortOrder?: AppsGetRequestSortOrder | (string & {});
}
export const GetAppRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    pageNo: S.optional(S.Number.pipe(T.Query("page_no"))),
    perPage: S.optional(S.Number.pipe(T.Query("per_page"))),
    search: S.optional(S.String.pipe(T.Query())),
    sortOrder: S.optional(AppsGetRequestSortOrder.pipe(T.Query("sort_order"))),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/realtime/kit/apps",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({ identifier: "GetAppRequest" }) as any as S.Schema<GetAppRequest>;

export interface AppsGetResponseDataItem {
  id?: string | null;
  createdAt?: string | null;
  name?: string | null;
}
export const AppsGetResponseDataItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.String)),
    createdAt: S.optional(S.NullOr(S.String).pipe(T.Body("created_at"))),
    name: S.optional(S.NullOr(S.String)),
  }),
).annotate({
  identifier: "AppsGetResponseDataItem",
}) as any as S.Schema<AppsGetResponseDataItem>;

export type AppsGetResponseDataList = Array<AppsGetResponseDataItem>;
export const AppsGetResponseDataList = /*@__PURE__*/ S.Array(
  AppsGetResponseDataItem,
) as any as S.Schema<AppsGetResponseDataList>;

export type AppsGetResponsePaging =
  LivestreamsGetAllLivestreamsResponseDataPaging;
export const AppsGetResponsePaging =
  LivestreamsGetAllLivestreamsResponseDataPaging;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface GetAppResponse {
  data?: AppsGetResponseDataList | null;
  paging?: LivestreamsGetAllLivestreamsResponseDataPaging | null;
}
export const GetAppResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    data: S.optional(S.NullOr(AppsGetResponseDataList)),
    paging: S.optional(
      S.NullOr(LivestreamsGetAllLivestreamsResponseDataPaging),
    ),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({ identifier: "GetAppResponse" }) as any as S.Schema<GetAppResponse>;

export interface GetLivestreamAnalyticsCompleteLivestreamRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  /** Specify the end time as a Unix timestamp in seconds to access the livestream analytics. */
  endTime?: number;
  /** Optional filters for livestream analytics. */
  filters?: string;
  /** Specify the start time as a Unix timestamp in seconds to access the livestream analytics. */
  startTime?: number;
}
export const GetLivestreamAnalyticsCompleteLivestreamRequest =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      accountId: S.String.pipe(T.Label("account_id")),
      appId: S.String.pipe(T.Label("app_id")),
      endTime: S.optional(S.Number.pipe(T.Query("end_time"))),
      filters: S.optional(S.String.pipe(T.Query())),
      startTime: S.optional(S.Number.pipe(T.Query("start_time"))),
    })
      .pipe(
        T.Http({
          method: "GET",
          uri: "/accounts/{account_id}/realtime/kit/{app_id}/analytics/livestreams/overall",
          code: 200,
        }),
      )
      .pipe(T.KeyDictionary(KEY_DICTIONARY)),
  ).annotate({
    identifier: "GetLivestreamAnalyticsCompleteLivestreamRequest",
  }) as any as S.Schema<GetLivestreamAnalyticsCompleteLivestreamRequest>;

export interface LivestreamsGetLivestreamAnalyticsCompleteResponseData {
  /** Count of total livestreams. */
  count?: number | null;
  /** Total time duration for which the input was given or the meeting was streamed. */
  totalIngestSeconds?: number | null;
  /** Total view time for which the viewers watched the stream. */
  totalViewerSeconds?: number | null;
}
export const LivestreamsGetLivestreamAnalyticsCompleteResponseData =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      count: S.optional(S.NullOr(S.Number)),
      totalIngestSeconds: S.optional(
        S.NullOr(S.Number).pipe(T.Body("total_ingest_seconds")),
      ),
      totalViewerSeconds: S.optional(
        S.NullOr(S.Number).pipe(T.Body("total_viewer_seconds")),
      ),
    }),
  ).annotate({
    identifier: "LivestreamsGetLivestreamAnalyticsCompleteResponseData",
  }) as any as S.Schema<LivestreamsGetLivestreamAnalyticsCompleteResponseData>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface GetLivestreamAnalyticsCompleteLivestreamResponse {
  data?: LivestreamsGetLivestreamAnalyticsCompleteResponseData | null;
}
export const GetLivestreamAnalyticsCompleteLivestreamResponse =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      data: S.optional(
        S.NullOr(LivestreamsGetLivestreamAnalyticsCompleteResponseData),
      ),
    }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
  ).annotate({
    identifier: "GetLivestreamAnalyticsCompleteLivestreamResponse",
  }) as any as S.Schema<GetLivestreamAnalyticsCompleteLivestreamResponse>;

export interface GetLivestreamAnalyticsDaywiseLivestreamRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  /** Specify the end time as a Unix timestamp in seconds to access the livestream analytics. */
  endTime?: number;
  /** Optional filters for livestream analytics. */
  filters?: string;
  /** Specify the start time as a Unix timestamp in seconds to access the livestream analytics. */
  startTime?: number;
}
export const GetLivestreamAnalyticsDaywiseLivestreamRequest =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      accountId: S.String.pipe(T.Label("account_id")),
      appId: S.String.pipe(T.Label("app_id")),
      endTime: S.optional(S.Number.pipe(T.Query("end_time"))),
      filters: S.optional(S.String.pipe(T.Query())),
      startTime: S.optional(S.Number.pipe(T.Query("start_time"))),
    })
      .pipe(
        T.Http({
          method: "GET",
          uri: "/accounts/{account_id}/realtime/kit/{app_id}/analytics/livestreams/daywise",
          code: 200,
        }),
      )
      .pipe(T.KeyDictionary(KEY_DICTIONARY)),
  ).annotate({
    identifier: "GetLivestreamAnalyticsDaywiseLivestreamRequest",
  }) as any as S.Schema<GetLivestreamAnalyticsDaywiseLivestreamRequest>;

export interface LivestreamsGetLivestreamAnalyticsDaywiseResponseDataItem {
  /** Count of total livestream sessions. */
  count?: number | null;
  /** Analytics date. */
  date?: string | null;
  /** Total time duration for which the input was given or the meeting was streamed. */
  totalIngestSeconds?: number | null;
  /** Total view time for which the viewers watched the stream. */
  totalViewerSeconds?: number | null;
}
export const LivestreamsGetLivestreamAnalyticsDaywiseResponseDataItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      count: S.optional(S.NullOr(S.Number)),
      date: S.optional(S.NullOr(S.String)),
      totalIngestSeconds: S.optional(
        S.NullOr(S.Number).pipe(T.Body("total_ingest_seconds")),
      ),
      totalViewerSeconds: S.optional(
        S.NullOr(S.Number).pipe(T.Body("total_viewer_seconds")),
      ),
    }),
  ).annotate({
    identifier: "LivestreamsGetLivestreamAnalyticsDaywiseResponseDataItem",
  }) as any as S.Schema<LivestreamsGetLivestreamAnalyticsDaywiseResponseDataItem>;

export type LivestreamsGetLivestreamAnalyticsDaywiseResponseDataList =
  Array<LivestreamsGetLivestreamAnalyticsDaywiseResponseDataItem>;
export const LivestreamsGetLivestreamAnalyticsDaywiseResponseDataList =
  /*@__PURE__*/ S.Array(
    LivestreamsGetLivestreamAnalyticsDaywiseResponseDataItem,
  ) as any as S.Schema<LivestreamsGetLivestreamAnalyticsDaywiseResponseDataList>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface GetLivestreamAnalyticsDaywiseLivestreamResponse {
  data?: LivestreamsGetLivestreamAnalyticsDaywiseResponseDataList | null;
}
export const GetLivestreamAnalyticsDaywiseLivestreamResponse =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      data: S.optional(
        S.NullOr(LivestreamsGetLivestreamAnalyticsDaywiseResponseDataList),
      ),
    }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
  ).annotate({
    identifier: "GetLivestreamAnalyticsDaywiseLivestreamResponse",
  }) as any as S.Schema<GetLivestreamAnalyticsDaywiseLivestreamResponse>;

export interface GetLivestreamSessionDetailsForSessionIdLivestreamRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  livestreamSessionId: string;
}
export const GetLivestreamSessionDetailsForSessionIdLivestreamRequest =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      accountId: S.String.pipe(T.Label("account_id")),
      appId: S.String.pipe(T.Label("app_id")),
      livestreamSessionId: S.String.pipe(T.Label("livestream_session_id")),
    })
      .pipe(
        T.Http({
          method: "GET",
          uri: "/accounts/{account_id}/realtime/kit/{app_id}/livestreams/sessions/{livestream_session_id}",
          code: 200,
        }),
      )
      .pipe(T.KeyDictionary(KEY_DICTIONARY)),
  ).annotate({
    identifier: "GetLivestreamSessionDetailsForSessionIdLivestreamRequest",
  }) as any as S.Schema<GetLivestreamSessionDetailsForSessionIdLivestreamRequest>;

export interface LivestreamsGetLivestreamSessionDetailsForSessionIdResponseData {
  /** The livestream ID. */
  id?: string | null;
  /** Timestamp the object was created at. The time is returned in ISO format. */
  createdAt?: string | null;
  /** The server URL to which the RTMP encoder sends the video and audio data. */
  errMessage?: string | null;
  /** Name of the livestream. */
  ingestSeconds?: number | null;
  livestreamId?: string | null;
  /** Unique key for accessing each livestream. */
  startedTime?: string | null;
  /** The web address that viewers can use to watch the livestream. */
  stoppedTime?: string | null;
  /** Timestamp the object was updated at. The time is returned in ISO format. */
  updatedAt?: string | null;
  /** Specifies if the livestream was disabled. */
  viewerSeconds?: number | null;
}
export const LivestreamsGetLivestreamSessionDetailsForSessionIdResponseData =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.optional(S.NullOr(S.String)),
      createdAt: S.optional(S.NullOr(S.String).pipe(T.Body("created_at"))),
      errMessage: S.optional(S.NullOr(S.String).pipe(T.Body("err_message"))),
      ingestSeconds: S.optional(
        S.NullOr(S.Number).pipe(T.Body("ingest_seconds")),
      ),
      livestreamId: S.optional(
        S.NullOr(S.String).pipe(T.Body("livestream_id")),
      ),
      startedTime: S.optional(S.NullOr(S.String).pipe(T.Body("started_time"))),
      stoppedTime: S.optional(S.NullOr(S.String).pipe(T.Body("stopped_time"))),
      updatedAt: S.optional(S.NullOr(S.String).pipe(T.Body("updated_at"))),
      viewerSeconds: S.optional(
        S.NullOr(S.Number).pipe(T.Body("viewer_seconds")),
      ),
    }),
  ).annotate({
    identifier:
      "LivestreamsGetLivestreamSessionDetailsForSessionIdResponseData",
  }) as any as S.Schema<LivestreamsGetLivestreamSessionDetailsForSessionIdResponseData>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface GetLivestreamSessionDetailsForSessionIdLivestreamResponse {
  data?: LivestreamsGetLivestreamSessionDetailsForSessionIdResponseData | null;
}
export const GetLivestreamSessionDetailsForSessionIdLivestreamResponse =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      data: S.optional(
        S.NullOr(
          LivestreamsGetLivestreamSessionDetailsForSessionIdResponseData,
        ),
      ),
    }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
  ).annotate({
    identifier: "GetLivestreamSessionDetailsForSessionIdLivestreamResponse",
  }) as any as S.Schema<GetLivestreamSessionDetailsForSessionIdLivestreamResponse>;

export interface GetLivestreamSessionForLivestreamIdLivestreamRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  livestreamId: string;
  /** The page number from which you want your page search results to be displayed. */
  pageNo?: number;
  /** Number of results per page. */
  perPage?: number;
}
export const GetLivestreamSessionForLivestreamIdLivestreamRequest =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      accountId: S.String.pipe(T.Label("account_id")),
      appId: S.String.pipe(T.Label("app_id")),
      livestreamId: S.String.pipe(T.Label("livestream_id")),
      pageNo: S.optional(S.Number.pipe(T.Query("page_no"))),
      perPage: S.optional(S.Number.pipe(T.Query("per_page"))),
    })
      .pipe(
        T.Http({
          method: "GET",
          uri: "/accounts/{account_id}/realtime/kit/{app_id}/livestreams/{livestream_id}",
          code: 200,
        }),
      )
      .pipe(T.KeyDictionary(KEY_DICTIONARY)),
  ).annotate({
    identifier: "GetLivestreamSessionForLivestreamIdLivestreamRequest",
  }) as any as S.Schema<GetLivestreamSessionForLivestreamIdLivestreamRequest>;

export type LivestreamsGetLivestreamSessionForLivestreamIdResponseDataLivestreamStatus =
  | "LIVE"
  | "IDLE"
  | "ERRORED"
  | "INVOKED";
export const LivestreamsGetLivestreamSessionForLivestreamIdResponseDataLivestreamStatus =
  /*@__PURE__*/ S.String;

export interface LivestreamsGetLivestreamSessionForLivestreamIdResponseDataLivestream {
  /** ID of the livestream. */
  id?: string | null;
  /** Timestamp the object was created at. The time is returned in ISO format. */
  createdAt?: string | null;
  /** Specifies if the livestream was disabled. */
  disabled?: string | null;
  /** The server URL to which the RTMP encoder sends the video and audio data. */
  ingestServer?: string | null;
  /** The ID of the meeting. */
  meetingId?: string | null;
  /** Name of the livestream. */
  name?: string | null;
  /** The web address that viewers can use to watch the livestream. */
  playbackUrl?: string | null;
  status?: LivestreamsGetLivestreamSessionForLivestreamIdResponseDataLivestreamStatus | null;
  /** Unique key for accessing each livestream. */
  streamKey?: string | null;
  /** Timestamp the object was updated at. The time is returned in ISO format. */
  updatedAt?: string | null;
}
export const LivestreamsGetLivestreamSessionForLivestreamIdResponseDataLivestream =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.optional(S.NullOr(S.String)),
      createdAt: S.optional(S.NullOr(S.String).pipe(T.Body("created_at"))),
      disabled: S.optional(S.NullOr(S.String)),
      ingestServer: S.optional(
        S.NullOr(S.String).pipe(T.Body("ingest_server")),
      ),
      meetingId: S.optional(S.NullOr(S.String).pipe(T.Body("meeting_id"))),
      name: S.optional(S.NullOr(S.String)),
      playbackUrl: S.optional(S.NullOr(S.String).pipe(T.Body("playback_url"))),
      status: S.optional(
        S.NullOr(
          LivestreamsGetLivestreamSessionForLivestreamIdResponseDataLivestreamStatus,
        ),
      ),
      streamKey: S.optional(S.NullOr(S.String).pipe(T.Body("stream_key"))),
      updatedAt: S.optional(S.NullOr(S.String).pipe(T.Body("updated_at"))),
    }),
  ).annotate({
    identifier:
      "LivestreamsGetLivestreamSessionForLivestreamIdResponseDataLivestream",
  }) as any as S.Schema<LivestreamsGetLivestreamSessionForLivestreamIdResponseDataLivestream>;

export type LivestreamsGetLivestreamSessionForLivestreamIdResponseDataPaging =
  LivestreamsGetAllLivestreamsResponseDataPaging;
export const LivestreamsGetLivestreamSessionForLivestreamIdResponseDataPaging =
  LivestreamsGetAllLivestreamsResponseDataPaging;

export interface LivestreamsGetLivestreamSessionForLivestreamIdResponseDataSession {
  /** ID of the session. */
  id?: string | null;
  /** Timestamp the object was created at. The time is returned in ISO format. */
  createdAt?: string | null;
  errMessage?: string | null;
  /** The time duration for which the input was given or the meeting was streamed. */
  ingestSeconds?: number | null;
  /** Timestamp the object was invoked. The time is returned in ISO format. */
  invokedTime?: string | null;
  livestreamId?: string | null;
  /** Timestamp the object was started. The time is returned in ISO format. */
  startedTime?: string | null;
  /** Timestamp the object was stopped. The time is returned in ISO format. */
  stoppedTime?: string | null;
  /** Timestamp the object was updated at. The time is returned in ISO format. */
  updatedAt?: string | null;
  /** The total view time for which the viewers watched the stream. */
  viewerSeconds?: number | null;
}
export const LivestreamsGetLivestreamSessionForLivestreamIdResponseDataSession =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.optional(S.NullOr(S.String)),
      createdAt: S.optional(S.NullOr(S.String).pipe(T.Body("created_at"))),
      errMessage: S.optional(S.NullOr(S.String).pipe(T.Body("err_message"))),
      ingestSeconds: S.optional(
        S.NullOr(S.Number).pipe(T.Body("ingest_seconds")),
      ),
      invokedTime: S.optional(S.NullOr(S.String).pipe(T.Body("invoked_time"))),
      livestreamId: S.optional(
        S.NullOr(S.String).pipe(T.Body("livestream_id")),
      ),
      startedTime: S.optional(S.NullOr(S.String).pipe(T.Body("started_time"))),
      stoppedTime: S.optional(S.NullOr(S.String).pipe(T.Body("stopped_time"))),
      updatedAt: S.optional(S.NullOr(S.String).pipe(T.Body("updated_at"))),
      viewerSeconds: S.optional(
        S.NullOr(S.Number).pipe(T.Body("viewer_seconds")),
      ),
    }),
  ).annotate({
    identifier:
      "LivestreamsGetLivestreamSessionForLivestreamIdResponseDataSession",
  }) as any as S.Schema<LivestreamsGetLivestreamSessionForLivestreamIdResponseDataSession>;

export interface LivestreamsGetLivestreamSessionForLivestreamIdResponseData {
  livestream?: LivestreamsGetLivestreamSessionForLivestreamIdResponseDataLivestream | null;
  paging?: LivestreamsGetAllLivestreamsResponseDataPaging | null;
  session?: LivestreamsGetLivestreamSessionForLivestreamIdResponseDataSession | null;
}
export const LivestreamsGetLivestreamSessionForLivestreamIdResponseData =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      livestream: S.optional(
        S.NullOr(
          LivestreamsGetLivestreamSessionForLivestreamIdResponseDataLivestream,
        ),
      ),
      paging: S.optional(
        S.NullOr(LivestreamsGetAllLivestreamsResponseDataPaging),
      ),
      session: S.optional(
        S.NullOr(
          LivestreamsGetLivestreamSessionForLivestreamIdResponseDataSession,
        ),
      ),
    }),
  ).annotate({
    identifier: "LivestreamsGetLivestreamSessionForLivestreamIdResponseData",
  }) as any as S.Schema<LivestreamsGetLivestreamSessionForLivestreamIdResponseData>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface GetLivestreamSessionForLivestreamIdLivestreamResponse {
  data?: LivestreamsGetLivestreamSessionForLivestreamIdResponseData | null;
}
export const GetLivestreamSessionForLivestreamIdLivestreamResponse =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      data: S.optional(
        S.NullOr(LivestreamsGetLivestreamSessionForLivestreamIdResponseData),
      ),
    }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
  ).annotate({
    identifier: "GetLivestreamSessionForLivestreamIdLivestreamResponse",
  }) as any as S.Schema<GetLivestreamSessionForLivestreamIdLivestreamResponse>;

export type MeetingsGetRequestStatus = "ACTIVE" | "INACTIVE";
export const MeetingsGetRequestStatus = /*@__PURE__*/ S.String;

export interface GetMeetingRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  /** The end time range for which you want to retrieve the meetings. The time must be specified in ISO format. */
  endTime?: string;
  /** The page number from which you want your page search results to be displayed. */
  pageNo?: number;
  /** Number of results per page */
  perPage?: number;
  /** The search query string. You can search using the meeting ID or title. */
  search?: string;
  /** The start time range for which you want to retrieve the meetings. The time must be specified in ISO format. */
  startTime?: string;
  /** Filter meetings by status. */
  status?: MeetingsGetRequestStatus | (string & {});
}
export const GetMeetingRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    appId: S.String.pipe(T.Label("app_id")),
    endTime: S.optional(S.String.pipe(T.Query("end_time"))),
    pageNo: S.optional(S.Number.pipe(T.Query("page_no"))),
    perPage: S.optional(S.Number.pipe(T.Query("per_page"))),
    search: S.optional(S.String.pipe(T.Query())),
    startTime: S.optional(S.String.pipe(T.Query("start_time"))),
    status: S.optional(MeetingsGetRequestStatus.pipe(T.Query())),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/realtime/kit/{app_id}/meetings",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetMeetingRequest",
}) as any as S.Schema<GetMeetingRequest>;

export type MeetingsGetResponseDataItemRecordingConfigAudioConfigChannel =
  | "mono"
  | "stereo";
export const MeetingsGetResponseDataItemRecordingConfigAudioConfigChannel =
  /*@__PURE__*/ S.String;

export type MeetingsGetResponseDataItemRecordingConfigAudioConfigCodec =
  | "MP3"
  | "AAC";
export const MeetingsGetResponseDataItemRecordingConfigAudioConfigCodec =
  /*@__PURE__*/ S.String;

export interface MeetingsGetResponseDataItemRecordingConfigAudioConfig {
  /** Audio signal pathway within an audio file that carries a specific sound source. */
  channel?: MeetingsGetResponseDataItemRecordingConfigAudioConfigChannel | null;
  /** Codec using which the recording will be encoded. If VP8/VP9 is selected for videoConfig, changing audioConfig is not allowed. In this case, the codec in the audioConfig is automatically set to vorbis. */
  codec?: MeetingsGetResponseDataItemRecordingConfigAudioConfigCodec | null;
  /** Controls whether to export audio file seperately */
  exportFile?: boolean | null;
}
export const MeetingsGetResponseDataItemRecordingConfigAudioConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      channel: S.optional(
        S.NullOr(MeetingsGetResponseDataItemRecordingConfigAudioConfigChannel),
      ),
      codec: S.optional(
        S.NullOr(MeetingsGetResponseDataItemRecordingConfigAudioConfigCodec),
      ),
      exportFile: S.optional(S.NullOr(S.Boolean).pipe(T.Body("export_file"))),
    }),
  ).annotate({
    identifier: "MeetingsGetResponseDataItemRecordingConfigAudioConfig",
  }) as any as S.Schema<MeetingsGetResponseDataItemRecordingConfigAudioConfig>;

export type MeetingsGetResponseDataItemRecordingConfigLiveStreamingConfig =
  MeetingsCreateResponseDataRecordingConfigLiveStreamingConfig;
export const MeetingsGetResponseDataItemRecordingConfigLiveStreamingConfig =
  MeetingsCreateResponseDataRecordingConfigLiveStreamingConfig;

export type MeetingsGetResponseDataItemRecordingConfigRealtimekitBucketConfig =
  MeetingsCreateRequestRecordingConfigRealtimekitBucketConfig;
export const MeetingsGetResponseDataItemRecordingConfigRealtimekitBucketConfig =
  MeetingsCreateRequestRecordingConfigRealtimekitBucketConfig;

export type MeetingsGetResponseDataItemRecordingConfigStorageConfigType =
  | "aws"
  | "azure"
  | "digitalocean"
  | "gcs"
  | "sftp";
export const MeetingsGetResponseDataItemRecordingConfigStorageConfigType =
  /*@__PURE__*/ S.String;

export type MeetingsGetResponseDataItemRecordingConfigStorageConfigAuthMethod =
  | "KEY"
  | "PASSWORD";
export const MeetingsGetResponseDataItemRecordingConfigStorageConfigAuthMethod =
  /*@__PURE__*/ S.String;

export interface MeetingsGetResponseDataItemRecordingConfigStorageConfig {
  /** Type of storage media. */
  type: MeetingsGetResponseDataItemRecordingConfigStorageConfigType;
  /** Access key of the storage medium. Access key is not required for the `gcs` storage media type. */
  accessKey?: string | null;
  /** Authentication method used for "sftp" type storage medium */
  authMethod?: MeetingsGetResponseDataItemRecordingConfigStorageConfigAuthMethod | null;
  /** Name of the storage medium's bucket. */
  bucket?: string | null;
  /** SSH destination server host for SFTP type storage medium */
  host?: string | null;
  /** SSH destination server password for SFTP type storage medium when auth_method is "PASSWORD". If auth_method is "KEY", this specifies the password for the ssh private key. */
  password?: string | null;
  /** Path relative to the bucket root at which the recording will be placed. */
  path?: string | null;
  /** SSH destination server port for SFTP type storage medium */
  port?: number | null;
  /** Private key used to login to destination SSH server for SFTP type storage medium, when auth_method used is "KEY" */
  privateKey?: string | null;
  /** Region of the storage medium. */
  region?: string | null;
  /** Secret key of the storage medium. Similar to `access_key`, it is only writeable by clients, not readable. */
  secret?: string | null;
  /** SSH destination server username for SFTP type storage medium */
  username?: string | null;
}
export const MeetingsGetResponseDataItemRecordingConfigStorageConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: MeetingsGetResponseDataItemRecordingConfigStorageConfigType,
      accessKey: S.optional(S.NullOr(S.String).pipe(T.Body("access_key"))),
      authMethod: S.optional(
        S.NullOr(
          MeetingsGetResponseDataItemRecordingConfigStorageConfigAuthMethod,
        ).pipe(T.Body("auth_method")),
      ),
      bucket: S.optional(S.NullOr(S.String)),
      host: S.optional(S.NullOr(S.String)),
      password: S.optional(S.NullOr(S.String)),
      path: S.optional(S.NullOr(S.String)),
      port: S.optional(S.NullOr(S.Number)),
      privateKey: S.optional(S.NullOr(S.String).pipe(T.Body("private_key"))),
      region: S.optional(S.NullOr(S.String)),
      secret: S.optional(S.NullOr(S.String)),
      username: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier: "MeetingsGetResponseDataItemRecordingConfigStorageConfig",
  }) as any as S.Schema<MeetingsGetResponseDataItemRecordingConfigStorageConfig>;

export type MeetingsGetResponseDataItemRecordingConfigVideoConfigCodec =
  | "H264"
  | "VP8";
export const MeetingsGetResponseDataItemRecordingConfigVideoConfigCodec =
  /*@__PURE__*/ S.String;

export type MeetingsGetResponseDataItemRecordingConfigVideoConfigWatermarkPosition =
  | "left top"
  | "right top"
  | "left bottom"
  | "right bottom";
export const MeetingsGetResponseDataItemRecordingConfigVideoConfigWatermarkPosition =
  /*@__PURE__*/ S.String;

export type MeetingsGetResponseDataItemRecordingConfigVideoConfigWatermarkSize =
  MeetingsCreateResponseDataRecordingConfigVideoConfigWatermarkSize;
export const MeetingsGetResponseDataItemRecordingConfigVideoConfigWatermarkSize =
  MeetingsCreateResponseDataRecordingConfigVideoConfigWatermarkSize;

export interface MeetingsGetResponseDataItemRecordingConfigVideoConfigWatermark {
  /** Position of the watermark */
  position?: MeetingsGetResponseDataItemRecordingConfigVideoConfigWatermarkPosition | null;
  /** Size of the watermark */
  size?: MeetingsCreateResponseDataRecordingConfigVideoConfigWatermarkSize | null;
  /** URL of the watermark image */
  url?: string | null;
}
export const MeetingsGetResponseDataItemRecordingConfigVideoConfigWatermark =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      position: S.optional(
        S.NullOr(
          MeetingsGetResponseDataItemRecordingConfigVideoConfigWatermarkPosition,
        ),
      ),
      size: S.optional(
        S.NullOr(
          MeetingsCreateResponseDataRecordingConfigVideoConfigWatermarkSize,
        ),
      ),
      url: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier:
      "MeetingsGetResponseDataItemRecordingConfigVideoConfigWatermark",
  }) as any as S.Schema<MeetingsGetResponseDataItemRecordingConfigVideoConfigWatermark>;

export interface MeetingsGetResponseDataItemRecordingConfigVideoConfig {
  /** Codec using which the recording will be encoded. */
  codec?: MeetingsGetResponseDataItemRecordingConfigVideoConfigCodec | null;
  /** Controls whether to export video file seperately */
  exportFile?: boolean | null;
  /** Height of the recording video in pixels */
  height?: number | null;
  /** Watermark to be added to the recording */
  watermark?: MeetingsGetResponseDataItemRecordingConfigVideoConfigWatermark | null;
  /** Width of the recording video in pixels */
  width?: number | null;
}
export const MeetingsGetResponseDataItemRecordingConfigVideoConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      codec: S.optional(
        S.NullOr(MeetingsGetResponseDataItemRecordingConfigVideoConfigCodec),
      ),
      exportFile: S.optional(S.NullOr(S.Boolean).pipe(T.Body("export_file"))),
      height: S.optional(S.NullOr(S.Number)),
      watermark: S.optional(
        S.NullOr(
          MeetingsGetResponseDataItemRecordingConfigVideoConfigWatermark,
        ),
      ),
      width: S.optional(S.NullOr(S.Number)),
    }),
  ).annotate({
    identifier: "MeetingsGetResponseDataItemRecordingConfigVideoConfig",
  }) as any as S.Schema<MeetingsGetResponseDataItemRecordingConfigVideoConfig>;

export interface MeetingsGetResponseDataItemRecordingConfig {
  /** Object containing configuration regarding the audio that is being recorded. */
  audioConfig?: MeetingsGetResponseDataItemRecordingConfigAudioConfig | null;
  /** Adds a prefix to the beginning of the file name of the recording. */
  fileNamePrefix?: string | null;
  liveStreamingConfig?: MeetingsCreateResponseDataRecordingConfigLiveStreamingConfig | null;
  /** Specifies the maximum duration for recording in seconds, ranging from a minimum of 60 seconds to a maximum of 24 hours. */
  maxSeconds?: number | null;
  realtimekitBucketConfig?: MeetingsCreateRequestRecordingConfigRealtimekitBucketConfig | null;
  storageConfig?: MeetingsGetResponseDataItemRecordingConfigStorageConfig | null;
  videoConfig?: MeetingsGetResponseDataItemRecordingConfigVideoConfig | null;
}
export const MeetingsGetResponseDataItemRecordingConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      audioConfig: S.optional(
        S.NullOr(MeetingsGetResponseDataItemRecordingConfigAudioConfig).pipe(
          T.Body("audio_config"),
        ),
      ),
      fileNamePrefix: S.optional(
        S.NullOr(S.String).pipe(T.Body("file_name_prefix")),
      ),
      liveStreamingConfig: S.optional(
        S.NullOr(
          MeetingsCreateResponseDataRecordingConfigLiveStreamingConfig,
        ).pipe(T.Body("live_streaming_config")),
      ),
      maxSeconds: S.optional(S.NullOr(S.Number).pipe(T.Body("max_seconds"))),
      realtimekitBucketConfig: S.optional(
        S.NullOr(
          MeetingsCreateRequestRecordingConfigRealtimekitBucketConfig,
        ).pipe(T.Body("realtimekit_bucket_config")),
      ),
      storageConfig: S.optional(
        S.NullOr(MeetingsGetResponseDataItemRecordingConfigStorageConfig).pipe(
          T.Body("storage_config"),
        ),
      ),
      videoConfig: S.optional(
        S.NullOr(MeetingsGetResponseDataItemRecordingConfigVideoConfig).pipe(
          T.Body("video_config"),
        ),
      ),
    }),
  ).annotate({
    identifier: "MeetingsGetResponseDataItemRecordingConfig",
  }) as any as S.Schema<MeetingsGetResponseDataItemRecordingConfig>;

export type MeetingsGetResponseDataItemStatus = "ACTIVE" | "INACTIVE";
export const MeetingsGetResponseDataItemStatus = /*@__PURE__*/ S.String;

export interface MeetingsGetResponseDataItem {
  /** ID of the meeting. */
  id: string;
  /** Timestamp the object was created at. The time is returned in ISO format. */
  createdAt: string;
  /** Timestamp the object was updated at. The time is returned in ISO format. */
  updatedAt: string;
  /** Specifies if the meeting should start getting livestreamed on start. */
  liveStreamOnStart?: boolean | null;
  /** Specifies if Chat within a meeting should persist for a week. */
  persistChat?: boolean | null;
  /** Specifies if the meeting should start getting recorded as soon as someone joins the meeting. */
  recordOnStart?: boolean | null;
  /** Recording Configurations to be used for this meeting. This level of configs takes higher preference over App level configs on the RealtimeKit developer portal. */
  recordingConfig?: MeetingsGetResponseDataItemRecordingConfig | null;
  /** Time in seconds, for which a session remains active, after the last participant has left the meeting. */
  sessionKeepAliveTimeInSecs?: number | null;
  /** Whether the meeting is `ACTIVE` or `INACTIVE`. Users will not be able to join an `INACTIVE` meeting. */
  status?: MeetingsGetResponseDataItemStatus | null;
  /** Automatically generate summary of meetings using transcripts. Requires Transcriptions to be enabled, and can be retrieved via Webhooks or summary API. */
  summarizeOnEnd?: boolean | null;
  /** Title of the meeting. */
  title?: string | null;
  /** Automatically generate transcripts when the meeting ends. */
  transcribeOnEnd?: boolean | null;
}
export const MeetingsGetResponseDataItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    createdAt: S.String.pipe(T.Body("created_at")),
    updatedAt: S.String.pipe(T.Body("updated_at")),
    liveStreamOnStart: S.optional(
      S.NullOr(S.Boolean).pipe(T.Body("live_stream_on_start")),
    ),
    persistChat: S.optional(S.NullOr(S.Boolean).pipe(T.Body("persist_chat"))),
    recordOnStart: S.optional(
      S.NullOr(S.Boolean).pipe(T.Body("record_on_start")),
    ),
    recordingConfig: S.optional(
      S.NullOr(MeetingsGetResponseDataItemRecordingConfig).pipe(
        T.Body("recording_config"),
      ),
    ),
    sessionKeepAliveTimeInSecs: S.optional(
      S.NullOr(S.Number).pipe(T.Body("session_keep_alive_time_in_secs")),
    ),
    status: S.optional(S.NullOr(MeetingsGetResponseDataItemStatus)),
    summarizeOnEnd: S.optional(
      S.NullOr(S.Boolean).pipe(T.Body("summarize_on_end")),
    ),
    title: S.optional(S.NullOr(S.String)),
    transcribeOnEnd: S.optional(
      S.NullOr(S.Boolean).pipe(T.Body("transcribe_on_end")),
    ),
  }),
).annotate({
  identifier: "MeetingsGetResponseDataItem",
}) as any as S.Schema<MeetingsGetResponseDataItem>;

export type MeetingsGetResponseDataList = Array<MeetingsGetResponseDataItem>;
export const MeetingsGetResponseDataList = /*@__PURE__*/ S.Array(
  MeetingsGetResponseDataItem,
) as any as S.Schema<MeetingsGetResponseDataList>;

export interface MeetingsGetResponsePaging {
  endOffset: number;
  startOffset: number;
  totalCount: number;
}
export const MeetingsGetResponsePaging = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    endOffset: S.Number.pipe(T.Body("end_offset")),
    startOffset: S.Number.pipe(T.Body("start_offset")),
    totalCount: S.Number.pipe(T.Body("total_count")),
  }),
).annotate({
  identifier: "MeetingsGetResponsePaging",
}) as any as S.Schema<MeetingsGetResponsePaging>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface GetMeetingResponse {
  data: MeetingsGetResponseDataList;
  paging: MeetingsGetResponsePaging;
}
export const GetMeetingResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    data: MeetingsGetResponseDataList,
    paging: MeetingsGetResponsePaging,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetMeetingResponse",
}) as any as S.Schema<GetMeetingResponse>;

export interface GetMeetingActiveLivestreamsLivestreamRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  meetingId: string;
}
export const GetMeetingActiveLivestreamsLivestreamRequest =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      accountId: S.String.pipe(T.Label("account_id")),
      appId: S.String.pipe(T.Label("app_id")),
      meetingId: S.String.pipe(T.Label("meeting_id")),
    })
      .pipe(
        T.Http({
          method: "GET",
          uri: "/accounts/{account_id}/realtime/kit/{app_id}/meetings/{meeting_id}/active-livestream",
          code: 200,
        }),
      )
      .pipe(T.KeyDictionary(KEY_DICTIONARY)),
  ).annotate({
    identifier: "GetMeetingActiveLivestreamsLivestreamRequest",
  }) as any as S.Schema<GetMeetingActiveLivestreamsLivestreamRequest>;

export type LivestreamsGetMeetingActiveLivestreamsResponseDataStatus =
  | "LIVE"
  | "IDLE"
  | "ERRORED"
  | "INVOKED";
export const LivestreamsGetMeetingActiveLivestreamsResponseDataStatus =
  /*@__PURE__*/ S.String;

export interface LivestreamsGetMeetingActiveLivestreamsResponseData {
  /** The livestream ID. */
  id?: string | null;
  /** Timestamp the object was created at. The time is returned in ISO format. */
  createdAt?: string | null;
  /** Specifies if the livestream was disabled. */
  disabled?: string | null;
  /** The server URL to which the RTMP encoder sends the video and audio data. */
  ingestServer?: string | null;
  meetingId?: string | null;
  /** Name of the livestream. */
  name?: string | null;
  /** The web address that viewers can use to watch the livestream. */
  playbackUrl?: string | null;
  status?: LivestreamsGetMeetingActiveLivestreamsResponseDataStatus | null;
  /** Unique key for accessing each livestream. */
  streamKey?: string | null;
  /** Timestamp the object was updated at. The time is returned in ISO format. */
  updatedAt?: string | null;
}
export const LivestreamsGetMeetingActiveLivestreamsResponseData =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.optional(S.NullOr(S.String)),
      createdAt: S.optional(S.NullOr(S.String).pipe(T.Body("created_at"))),
      disabled: S.optional(S.NullOr(S.String)),
      ingestServer: S.optional(
        S.NullOr(S.String).pipe(T.Body("ingest_server")),
      ),
      meetingId: S.optional(S.NullOr(S.String).pipe(T.Body("meeting_id"))),
      name: S.optional(S.NullOr(S.String)),
      playbackUrl: S.optional(S.NullOr(S.String).pipe(T.Body("playback_url"))),
      status: S.optional(
        S.NullOr(LivestreamsGetMeetingActiveLivestreamsResponseDataStatus),
      ),
      streamKey: S.optional(S.NullOr(S.String).pipe(T.Body("stream_key"))),
      updatedAt: S.optional(S.NullOr(S.String).pipe(T.Body("updated_at"))),
    }),
  ).annotate({
    identifier: "LivestreamsGetMeetingActiveLivestreamsResponseData",
  }) as any as S.Schema<LivestreamsGetMeetingActiveLivestreamsResponseData>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface GetMeetingActiveLivestreamsLivestreamResponse {
  data?: LivestreamsGetMeetingActiveLivestreamsResponseData | null;
}
export const GetMeetingActiveLivestreamsLivestreamResponse =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      data: S.optional(
        S.NullOr(LivestreamsGetMeetingActiveLivestreamsResponseData),
      ),
    }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
  ).annotate({
    identifier: "GetMeetingActiveLivestreamsLivestreamResponse",
  }) as any as S.Schema<GetMeetingActiveLivestreamsLivestreamResponse>;

export interface GetMeetingByIdMeetingRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  meetingId: string;
  name?: string;
}
export const GetMeetingByIdMeetingRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    appId: S.String.pipe(T.Label("app_id")),
    meetingId: S.String.pipe(T.Label("meeting_id")),
    name: S.optional(S.String.pipe(T.Query())),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/realtime/kit/{app_id}/meetings/{meeting_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetMeetingByIdMeetingRequest",
}) as any as S.Schema<GetMeetingByIdMeetingRequest>;

export type MeetingsGetMeetingByIdResponseDataAiConfigSummarizationSummaryType =
  | "general"
  | "team_meeting"
  | "sales_call"
  | "client_check_in"
  | "interview"
  | "daily_standup"
  | "one_on_one_meeting"
  | "lecture"
  | "code_review";
export const MeetingsGetMeetingByIdResponseDataAiConfigSummarizationSummaryType =
  /*@__PURE__*/ S.String;

export type MeetingsGetMeetingByIdResponseDataAiConfigSummarizationTextFormat =
  | "plain_text"
  | "markdown";
export const MeetingsGetMeetingByIdResponseDataAiConfigSummarizationTextFormat =
  /*@__PURE__*/ S.String;

export interface MeetingsGetMeetingByIdResponseDataAiConfigSummarization {
  /** Defines the style of the summary, such as general, team meeting, or sales call. */
  summaryType?: MeetingsGetMeetingByIdResponseDataAiConfigSummarizationSummaryType | null;
  /** Determines the text format of the summary, such as plain text or markdown. */
  textFormat?: MeetingsGetMeetingByIdResponseDataAiConfigSummarizationTextFormat | null;
  /** Sets the maximum number of words in the meeting summary. */
  wordLimit?: number | null;
}
export const MeetingsGetMeetingByIdResponseDataAiConfigSummarization =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      summaryType: S.optional(
        S.NullOr(
          MeetingsGetMeetingByIdResponseDataAiConfigSummarizationSummaryType,
        ).pipe(T.Body("summary_type")),
      ),
      textFormat: S.optional(
        S.NullOr(
          MeetingsGetMeetingByIdResponseDataAiConfigSummarizationTextFormat,
        ).pipe(T.Body("text_format")),
      ),
      wordLimit: S.optional(S.NullOr(S.Number).pipe(T.Body("word_limit"))),
    }),
  ).annotate({
    identifier: "MeetingsGetMeetingByIdResponseDataAiConfigSummarization",
  }) as any as S.Schema<MeetingsGetMeetingByIdResponseDataAiConfigSummarization>;

export type MeetingsGetMeetingByIdResponseDataAiConfigTranscriptionKeywordsList =
  Array<string>;
export const MeetingsGetMeetingByIdResponseDataAiConfigTranscriptionKeywordsList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<MeetingsGetMeetingByIdResponseDataAiConfigTranscriptionKeywordsList>;

export type MeetingsGetMeetingByIdResponseDataAiConfigTranscriptionLanguage =
  | "en-US"
  | "en-IN"
  | "de"
  | "hi"
  | "sv"
  | "ru"
  | "pl"
  | "el"
  | "fr"
  | "nl";
export const MeetingsGetMeetingByIdResponseDataAiConfigTranscriptionLanguage =
  /*@__PURE__*/ S.String;

export interface MeetingsGetMeetingByIdResponseDataAiConfigTranscription {
  /** Adds specific terms to improve accurate detection during transcription. */
  keywords?: MeetingsGetMeetingByIdResponseDataAiConfigTranscriptionKeywordsList | null;
  /** Specifies the language code for transcription to ensure accurate results. */
  language?: MeetingsGetMeetingByIdResponseDataAiConfigTranscriptionLanguage | null;
  /** Control the inclusion of offensive language in transcriptions. */
  profanityFilter?: boolean | null;
}
export const MeetingsGetMeetingByIdResponseDataAiConfigTranscription =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      keywords: S.optional(
        S.NullOr(
          MeetingsGetMeetingByIdResponseDataAiConfigTranscriptionKeywordsList,
        ),
      ),
      language: S.optional(
        S.NullOr(
          MeetingsGetMeetingByIdResponseDataAiConfigTranscriptionLanguage,
        ),
      ),
      profanityFilter: S.optional(
        S.NullOr(S.Boolean).pipe(T.Body("profanity_filter")),
      ),
    }),
  ).annotate({
    identifier: "MeetingsGetMeetingByIdResponseDataAiConfigTranscription",
  }) as any as S.Schema<MeetingsGetMeetingByIdResponseDataAiConfigTranscription>;

export interface MeetingsGetMeetingByIdResponseDataAiConfig {
  /** Summary Config */
  summarization?: MeetingsGetMeetingByIdResponseDataAiConfigSummarization | null;
  /** Transcription Configurations */
  transcription?: MeetingsGetMeetingByIdResponseDataAiConfigTranscription | null;
}
export const MeetingsGetMeetingByIdResponseDataAiConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      summarization: S.optional(
        S.NullOr(MeetingsGetMeetingByIdResponseDataAiConfigSummarization),
      ),
      transcription: S.optional(
        S.NullOr(MeetingsGetMeetingByIdResponseDataAiConfigTranscription),
      ),
    }),
  ).annotate({
    identifier: "MeetingsGetMeetingByIdResponseDataAiConfig",
  }) as any as S.Schema<MeetingsGetMeetingByIdResponseDataAiConfig>;

export type MeetingsGetMeetingByIdResponseDataRecordingConfigAudioConfigChannel =
  | "mono"
  | "stereo";
export const MeetingsGetMeetingByIdResponseDataRecordingConfigAudioConfigChannel =
  /*@__PURE__*/ S.String;

export type MeetingsGetMeetingByIdResponseDataRecordingConfigAudioConfigCodec =
  | "MP3"
  | "AAC";
export const MeetingsGetMeetingByIdResponseDataRecordingConfigAudioConfigCodec =
  /*@__PURE__*/ S.String;

export interface MeetingsGetMeetingByIdResponseDataRecordingConfigAudioConfig {
  /** Audio signal pathway within an audio file that carries a specific sound source. */
  channel?: MeetingsGetMeetingByIdResponseDataRecordingConfigAudioConfigChannel | null;
  /** Codec using which the recording will be encoded. If VP8/VP9 is selected for videoConfig, changing audioConfig is not allowed. In this case, the codec in the audioConfig is automatically set to vorbis. */
  codec?: MeetingsGetMeetingByIdResponseDataRecordingConfigAudioConfigCodec | null;
  /** Controls whether to export audio file seperately */
  exportFile?: boolean | null;
}
export const MeetingsGetMeetingByIdResponseDataRecordingConfigAudioConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      channel: S.optional(
        S.NullOr(
          MeetingsGetMeetingByIdResponseDataRecordingConfigAudioConfigChannel,
        ),
      ),
      codec: S.optional(
        S.NullOr(
          MeetingsGetMeetingByIdResponseDataRecordingConfigAudioConfigCodec,
        ),
      ),
      exportFile: S.optional(S.NullOr(S.Boolean).pipe(T.Body("export_file"))),
    }),
  ).annotate({
    identifier: "MeetingsGetMeetingByIdResponseDataRecordingConfigAudioConfig",
  }) as any as S.Schema<MeetingsGetMeetingByIdResponseDataRecordingConfigAudioConfig>;

export type MeetingsGetMeetingByIdResponseDataRecordingConfigLiveStreamingConfig =
  MeetingsCreateResponseDataRecordingConfigLiveStreamingConfig;
export const MeetingsGetMeetingByIdResponseDataRecordingConfigLiveStreamingConfig =
  MeetingsCreateResponseDataRecordingConfigLiveStreamingConfig;

export type MeetingsGetMeetingByIdResponseDataRecordingConfigRealtimekitBucketConfig =
  MeetingsCreateRequestRecordingConfigRealtimekitBucketConfig;
export const MeetingsGetMeetingByIdResponseDataRecordingConfigRealtimekitBucketConfig =
  MeetingsCreateRequestRecordingConfigRealtimekitBucketConfig;

export type MeetingsGetMeetingByIdResponseDataRecordingConfigStorageConfigType =
  | "aws"
  | "azure"
  | "digitalocean"
  | "gcs"
  | "sftp";
export const MeetingsGetMeetingByIdResponseDataRecordingConfigStorageConfigType =
  /*@__PURE__*/ S.String;

export type MeetingsGetMeetingByIdResponseDataRecordingConfigStorageConfigAuthMethod =
  | "KEY"
  | "PASSWORD";
export const MeetingsGetMeetingByIdResponseDataRecordingConfigStorageConfigAuthMethod =
  /*@__PURE__*/ S.String;

export interface MeetingsGetMeetingByIdResponseDataRecordingConfigStorageConfig {
  /** Type of storage media. */
  type: MeetingsGetMeetingByIdResponseDataRecordingConfigStorageConfigType;
  /** Access key of the storage medium. Access key is not required for the `gcs` storage media type. */
  accessKey?: string | null;
  /** Authentication method used for "sftp" type storage medium */
  authMethod?: MeetingsGetMeetingByIdResponseDataRecordingConfigStorageConfigAuthMethod | null;
  /** Name of the storage medium's bucket. */
  bucket?: string | null;
  /** SSH destination server host for SFTP type storage medium */
  host?: string | null;
  /** SSH destination server password for SFTP type storage medium when auth_method is "PASSWORD". If auth_method is "KEY", this specifies the password for the ssh private key. */
  password?: string | null;
  /** Path relative to the bucket root at which the recording will be placed. */
  path?: string | null;
  /** SSH destination server port for SFTP type storage medium */
  port?: number | null;
  /** Private key used to login to destination SSH server for SFTP type storage medium, when auth_method used is "KEY" */
  privateKey?: string | null;
  /** Region of the storage medium. */
  region?: string | null;
  /** Secret key of the storage medium. Similar to `access_key`, it is only writeable by clients, not readable. */
  secret?: string | null;
  /** SSH destination server username for SFTP type storage medium */
  username?: string | null;
}
export const MeetingsGetMeetingByIdResponseDataRecordingConfigStorageConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: MeetingsGetMeetingByIdResponseDataRecordingConfigStorageConfigType,
      accessKey: S.optional(S.NullOr(S.String).pipe(T.Body("access_key"))),
      authMethod: S.optional(
        S.NullOr(
          MeetingsGetMeetingByIdResponseDataRecordingConfigStorageConfigAuthMethod,
        ).pipe(T.Body("auth_method")),
      ),
      bucket: S.optional(S.NullOr(S.String)),
      host: S.optional(S.NullOr(S.String)),
      password: S.optional(S.NullOr(S.String)),
      path: S.optional(S.NullOr(S.String)),
      port: S.optional(S.NullOr(S.Number)),
      privateKey: S.optional(S.NullOr(S.String).pipe(T.Body("private_key"))),
      region: S.optional(S.NullOr(S.String)),
      secret: S.optional(S.NullOr(S.String)),
      username: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier:
      "MeetingsGetMeetingByIdResponseDataRecordingConfigStorageConfig",
  }) as any as S.Schema<MeetingsGetMeetingByIdResponseDataRecordingConfigStorageConfig>;

export type MeetingsGetMeetingByIdResponseDataRecordingConfigVideoConfigCodec =
  | "H264"
  | "VP8";
export const MeetingsGetMeetingByIdResponseDataRecordingConfigVideoConfigCodec =
  /*@__PURE__*/ S.String;

export type MeetingsGetMeetingByIdResponseDataRecordingConfigVideoConfigWatermarkPosition =
  | "left top"
  | "right top"
  | "left bottom"
  | "right bottom";
export const MeetingsGetMeetingByIdResponseDataRecordingConfigVideoConfigWatermarkPosition =
  /*@__PURE__*/ S.String;

export type MeetingsGetMeetingByIdResponseDataRecordingConfigVideoConfigWatermarkSize =
  MeetingsCreateResponseDataRecordingConfigVideoConfigWatermarkSize;
export const MeetingsGetMeetingByIdResponseDataRecordingConfigVideoConfigWatermarkSize =
  MeetingsCreateResponseDataRecordingConfigVideoConfigWatermarkSize;

export interface MeetingsGetMeetingByIdResponseDataRecordingConfigVideoConfigWatermark {
  /** Position of the watermark */
  position?: MeetingsGetMeetingByIdResponseDataRecordingConfigVideoConfigWatermarkPosition | null;
  /** Size of the watermark */
  size?: MeetingsCreateResponseDataRecordingConfigVideoConfigWatermarkSize | null;
  /** URL of the watermark image */
  url?: string | null;
}
export const MeetingsGetMeetingByIdResponseDataRecordingConfigVideoConfigWatermark =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      position: S.optional(
        S.NullOr(
          MeetingsGetMeetingByIdResponseDataRecordingConfigVideoConfigWatermarkPosition,
        ),
      ),
      size: S.optional(
        S.NullOr(
          MeetingsCreateResponseDataRecordingConfigVideoConfigWatermarkSize,
        ),
      ),
      url: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier:
      "MeetingsGetMeetingByIdResponseDataRecordingConfigVideoConfigWatermark",
  }) as any as S.Schema<MeetingsGetMeetingByIdResponseDataRecordingConfigVideoConfigWatermark>;

export interface MeetingsGetMeetingByIdResponseDataRecordingConfigVideoConfig {
  /** Codec using which the recording will be encoded. */
  codec?: MeetingsGetMeetingByIdResponseDataRecordingConfigVideoConfigCodec | null;
  /** Controls whether to export video file seperately */
  exportFile?: boolean | null;
  /** Height of the recording video in pixels */
  height?: number | null;
  /** Watermark to be added to the recording */
  watermark?: MeetingsGetMeetingByIdResponseDataRecordingConfigVideoConfigWatermark | null;
  /** Width of the recording video in pixels */
  width?: number | null;
}
export const MeetingsGetMeetingByIdResponseDataRecordingConfigVideoConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      codec: S.optional(
        S.NullOr(
          MeetingsGetMeetingByIdResponseDataRecordingConfigVideoConfigCodec,
        ),
      ),
      exportFile: S.optional(S.NullOr(S.Boolean).pipe(T.Body("export_file"))),
      height: S.optional(S.NullOr(S.Number)),
      watermark: S.optional(
        S.NullOr(
          MeetingsGetMeetingByIdResponseDataRecordingConfigVideoConfigWatermark,
        ),
      ),
      width: S.optional(S.NullOr(S.Number)),
    }),
  ).annotate({
    identifier: "MeetingsGetMeetingByIdResponseDataRecordingConfigVideoConfig",
  }) as any as S.Schema<MeetingsGetMeetingByIdResponseDataRecordingConfigVideoConfig>;

export interface MeetingsGetMeetingByIdResponseDataRecordingConfig {
  /** Object containing configuration regarding the audio that is being recorded. */
  audioConfig?: MeetingsGetMeetingByIdResponseDataRecordingConfigAudioConfig | null;
  /** Adds a prefix to the beginning of the file name of the recording. */
  fileNamePrefix?: string | null;
  liveStreamingConfig?: MeetingsCreateResponseDataRecordingConfigLiveStreamingConfig | null;
  /** Specifies the maximum duration for recording in seconds, ranging from a minimum of 60 seconds to a maximum of 24 hours. */
  maxSeconds?: number | null;
  realtimekitBucketConfig?: MeetingsCreateRequestRecordingConfigRealtimekitBucketConfig | null;
  storageConfig?: MeetingsGetMeetingByIdResponseDataRecordingConfigStorageConfig | null;
  videoConfig?: MeetingsGetMeetingByIdResponseDataRecordingConfigVideoConfig | null;
}
export const MeetingsGetMeetingByIdResponseDataRecordingConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      audioConfig: S.optional(
        S.NullOr(
          MeetingsGetMeetingByIdResponseDataRecordingConfigAudioConfig,
        ).pipe(T.Body("audio_config")),
      ),
      fileNamePrefix: S.optional(
        S.NullOr(S.String).pipe(T.Body("file_name_prefix")),
      ),
      liveStreamingConfig: S.optional(
        S.NullOr(
          MeetingsCreateResponseDataRecordingConfigLiveStreamingConfig,
        ).pipe(T.Body("live_streaming_config")),
      ),
      maxSeconds: S.optional(S.NullOr(S.Number).pipe(T.Body("max_seconds"))),
      realtimekitBucketConfig: S.optional(
        S.NullOr(
          MeetingsCreateRequestRecordingConfigRealtimekitBucketConfig,
        ).pipe(T.Body("realtimekit_bucket_config")),
      ),
      storageConfig: S.optional(
        S.NullOr(
          MeetingsGetMeetingByIdResponseDataRecordingConfigStorageConfig,
        ).pipe(T.Body("storage_config")),
      ),
      videoConfig: S.optional(
        S.NullOr(
          MeetingsGetMeetingByIdResponseDataRecordingConfigVideoConfig,
        ).pipe(T.Body("video_config")),
      ),
    }),
  ).annotate({
    identifier: "MeetingsGetMeetingByIdResponseDataRecordingConfig",
  }) as any as S.Schema<MeetingsGetMeetingByIdResponseDataRecordingConfig>;

export type MeetingsGetMeetingByIdResponseDataStatus = "ACTIVE" | "INACTIVE";
export const MeetingsGetMeetingByIdResponseDataStatus = /*@__PURE__*/ S.String;

export interface MeetingsGetMeetingByIdResponseData {
  /** ID of the meeting. */
  id: string;
  /** Timestamp the object was created at. The time is returned in ISO format. */
  createdAt: string;
  /** Timestamp the object was updated at. The time is returned in ISO format. */
  updatedAt: string;
  /** The AI Config allows you to customize the behavior of meeting transcriptions and summaries */
  aiConfig?: MeetingsGetMeetingByIdResponseDataAiConfig | null;
  /** Specifies if the meeting should start getting livestreamed on start. */
  liveStreamOnStart?: boolean | null;
  /** Specifies if Chat within a meeting should persist for a week. */
  persistChat?: boolean | null;
  /** Specifies if the meeting should start getting recorded as soon as someone joins the meeting. */
  recordOnStart?: boolean | null;
  /** Recording Configurations to be used for this meeting. This level of configs takes higher preference over App level configs on the RealtimeKit developer portal. */
  recordingConfig?: MeetingsGetMeetingByIdResponseDataRecordingConfig | null;
  /** Time in seconds, for which a session remains active, after the last participant has left the meeting. */
  sessionKeepAliveTimeInSecs?: number | null;
  /** Whether the meeting is `ACTIVE` or `INACTIVE`. Users will not be able to join an `INACTIVE` meeting. */
  status?: MeetingsGetMeetingByIdResponseDataStatus | null;
  /** Automatically generate summary of meetings using transcripts. Requires Transcriptions to be enabled, and can be retrieved via Webhooks or summary API. */
  summarizeOnEnd?: boolean | null;
  /** Title of the meeting. */
  title?: string | null;
  /** Automatically generate transcripts when the meeting ends. */
  transcribeOnEnd?: boolean | null;
}
export const MeetingsGetMeetingByIdResponseData = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    createdAt: S.String.pipe(T.Body("created_at")),
    updatedAt: S.String.pipe(T.Body("updated_at")),
    aiConfig: S.optional(
      S.NullOr(MeetingsGetMeetingByIdResponseDataAiConfig).pipe(
        T.Body("ai_config"),
      ),
    ),
    liveStreamOnStart: S.optional(
      S.NullOr(S.Boolean).pipe(T.Body("live_stream_on_start")),
    ),
    persistChat: S.optional(S.NullOr(S.Boolean).pipe(T.Body("persist_chat"))),
    recordOnStart: S.optional(
      S.NullOr(S.Boolean).pipe(T.Body("record_on_start")),
    ),
    recordingConfig: S.optional(
      S.NullOr(MeetingsGetMeetingByIdResponseDataRecordingConfig).pipe(
        T.Body("recording_config"),
      ),
    ),
    sessionKeepAliveTimeInSecs: S.optional(
      S.NullOr(S.Number).pipe(T.Body("session_keep_alive_time_in_secs")),
    ),
    status: S.optional(S.NullOr(MeetingsGetMeetingByIdResponseDataStatus)),
    summarizeOnEnd: S.optional(
      S.NullOr(S.Boolean).pipe(T.Body("summarize_on_end")),
    ),
    title: S.optional(S.NullOr(S.String)),
    transcribeOnEnd: S.optional(
      S.NullOr(S.Boolean).pipe(T.Body("transcribe_on_end")),
    ),
  }),
).annotate({
  identifier: "MeetingsGetMeetingByIdResponseData",
}) as any as S.Schema<MeetingsGetMeetingByIdResponseData>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface GetMeetingByIdMeetingResponse {
  /** Data returned by the operation */
  data?: MeetingsGetMeetingByIdResponseData | null;
}
export const GetMeetingByIdMeetingResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    data: S.optional(S.NullOr(MeetingsGetMeetingByIdResponseData)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetMeetingByIdMeetingResponse",
}) as any as S.Schema<GetMeetingByIdMeetingResponse>;

export interface GetMeetingParticipantMeetingRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  meetingId: string;
  participantId: string;
}
export const GetMeetingParticipantMeetingRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    appId: S.String.pipe(T.Label("app_id")),
    meetingId: S.String.pipe(T.Label("meeting_id")),
    participantId: S.String.pipe(T.Label("participant_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/realtime/kit/{app_id}/meetings/{meeting_id}/participants/{participant_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetMeetingParticipantMeetingRequest",
}) as any as S.Schema<GetMeetingParticipantMeetingRequest>;

export interface MeetingsGetMeetingParticipantResponseData {
  /** ID of the participant. */
  id: string;
  /** When this object was created. The time is returned in ISO format. */
  createdAt: string;
  /** A unique participant ID generated by the client. */
  customParticipantId: string;
  /** Preset applied to the participant. */
  presetName: string;
  /** When this object was updated. The time is returned in ISO format. */
  updatedAt: string;
  /** Name of the participant. */
  name?: string | null;
  /** URL to a picture of the participant. */
  picture?: string | null;
}
export const MeetingsGetMeetingParticipantResponseData =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      createdAt: S.String.pipe(T.Body("created_at")),
      customParticipantId: S.String.pipe(T.Body("custom_participant_id")),
      presetName: S.String.pipe(T.Body("preset_name")),
      updatedAt: S.String.pipe(T.Body("updated_at")),
      name: S.optional(S.NullOr(S.String)),
      picture: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier: "MeetingsGetMeetingParticipantResponseData",
  }) as any as S.Schema<MeetingsGetMeetingParticipantResponseData>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface GetMeetingParticipantMeetingResponse {
  /** Data returned by the operation */
  data: MeetingsGetMeetingParticipantResponseData;
}
export const GetMeetingParticipantMeetingResponse = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      data: MeetingsGetMeetingParticipantResponseData,
    }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetMeetingParticipantMeetingResponse",
}) as any as S.Schema<GetMeetingParticipantMeetingResponse>;

export interface GetMeetingParticipantsMeetingRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  meetingId: string;
  /** The page number from which you want your page search results to be displayed. */
  pageNo?: number;
  /** Number of results per page */
  perPage?: number;
}
export const GetMeetingParticipantsMeetingRequest = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      accountId: S.String.pipe(T.Label("account_id")),
      appId: S.String.pipe(T.Label("app_id")),
      meetingId: S.String.pipe(T.Label("meeting_id")),
      pageNo: S.optional(S.Number.pipe(T.Query("page_no"))),
      perPage: S.optional(S.Number.pipe(T.Query("per_page"))),
    })
      .pipe(
        T.Http({
          method: "GET",
          uri: "/accounts/{account_id}/realtime/kit/{app_id}/meetings/{meeting_id}/participants",
          code: 200,
        }),
      )
      .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetMeetingParticipantsMeetingRequest",
}) as any as S.Schema<GetMeetingParticipantsMeetingRequest>;

export type MeetingsGetMeetingParticipantsResponseDataItem =
  MeetingsGetMeetingParticipantResponseData;
export const MeetingsGetMeetingParticipantsResponseDataItem =
  MeetingsGetMeetingParticipantResponseData;

export type MeetingsGetMeetingParticipantsResponseDataList =
  Array<MeetingsGetMeetingParticipantResponseData>;
export const MeetingsGetMeetingParticipantsResponseDataList =
  /*@__PURE__*/ S.Array(
    MeetingsGetMeetingParticipantResponseData,
  ) as any as S.Schema<MeetingsGetMeetingParticipantsResponseDataList>;

export type MeetingsGetMeetingParticipantsResponsePaging =
  MeetingsGetResponsePaging;
export const MeetingsGetMeetingParticipantsResponsePaging =
  MeetingsGetResponsePaging;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface GetMeetingParticipantsMeetingResponse {
  data: MeetingsGetMeetingParticipantsResponseDataList;
  paging: MeetingsGetResponsePaging;
}
export const GetMeetingParticipantsMeetingResponse = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      data: MeetingsGetMeetingParticipantsResponseDataList,
      paging: MeetingsGetResponsePaging,
    }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetMeetingParticipantsMeetingResponse",
}) as any as S.Schema<GetMeetingParticipantsMeetingResponse>;

export interface GetOneRecordingRecordingRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  recordingId: string;
}
export const GetOneRecordingRecordingRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    appId: S.String.pipe(T.Label("app_id")),
    recordingId: S.String.pipe(T.Label("recording_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/realtime/kit/{app_id}/recordings/{recording_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetOneRecordingRecordingRequest",
}) as any as S.Schema<GetOneRecordingRecordingRequest>;

export type RecordingsGetOneRecordingResponseDataStatus =
  | "INVOKED"
  | "RECORDING"
  | "UPLOADING"
  | "UPLOADED"
  | "ERRORED"
  | "PAUSED";
export const RecordingsGetOneRecordingResponseDataStatus =
  /*@__PURE__*/ S.String;

export type RecordingsGetOneRecordingResponseDataStartReasonCallerType =
  | "ORGANIZATION"
  | "USER";
export const RecordingsGetOneRecordingResponseDataStartReasonCallerType =
  /*@__PURE__*/ S.String;

export interface RecordingsGetOneRecordingResponseDataStartReasonCaller {
  /** Name of the user who started the recording. */
  name?: string | null;
  /** The type can be an App or a user. If the type is `user`, then only the `user_Id` and `name` are returned. */
  type?: RecordingsGetOneRecordingResponseDataStartReasonCallerType | null;
  /** The user ID of the person who started the recording. */
  userId?: string | null;
}
export const RecordingsGetOneRecordingResponseDataStartReasonCaller =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      name: S.optional(S.NullOr(S.String)),
      type: S.optional(
        S.NullOr(RecordingsGetOneRecordingResponseDataStartReasonCallerType),
      ),
      userId: S.optional(S.NullOr(S.String).pipe(T.Body("user_Id"))),
    }),
  ).annotate({
    identifier: "RecordingsGetOneRecordingResponseDataStartReasonCaller",
  }) as any as S.Schema<RecordingsGetOneRecordingResponseDataStartReasonCaller>;

export type RecordingsGetOneRecordingResponseDataStartReasonReason =
  | "API_CALL"
  | "RECORD_ON_START";
export const RecordingsGetOneRecordingResponseDataStartReasonReason =
  /*@__PURE__*/ S.String;

export interface RecordingsGetOneRecordingResponseDataStartReason {
  caller?: RecordingsGetOneRecordingResponseDataStartReasonCaller | null;
  /** Specifies if the recording was started using the "Start a Recording"API or using the parameter RECORD_ON_START in the "Create a meeting" API. */
  reason?: RecordingsGetOneRecordingResponseDataStartReasonReason | null;
}
export const RecordingsGetOneRecordingResponseDataStartReason =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      caller: S.optional(
        S.NullOr(RecordingsGetOneRecordingResponseDataStartReasonCaller),
      ),
      reason: S.optional(
        S.NullOr(RecordingsGetOneRecordingResponseDataStartReasonReason),
      ),
    }),
  ).annotate({
    identifier: "RecordingsGetOneRecordingResponseDataStartReason",
  }) as any as S.Schema<RecordingsGetOneRecordingResponseDataStartReason>;

export type RecordingsGetOneRecordingResponseDataStopReasonCallerType =
  | "ORGANIZATION"
  | "USER";
export const RecordingsGetOneRecordingResponseDataStopReasonCallerType =
  /*@__PURE__*/ S.String;

export interface RecordingsGetOneRecordingResponseDataStopReasonCaller {
  /** Name of the user who stopped the recording. */
  name?: string | null;
  /** The type can be an App or a user. If the type is `user`, then only the `user_Id` and `name` are returned. */
  type?: RecordingsGetOneRecordingResponseDataStopReasonCallerType | null;
  /** The user ID of the person who stopped the recording. */
  userId?: string | null;
}
export const RecordingsGetOneRecordingResponseDataStopReasonCaller =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      name: S.optional(S.NullOr(S.String)),
      type: S.optional(
        S.NullOr(RecordingsGetOneRecordingResponseDataStopReasonCallerType),
      ),
      userId: S.optional(S.NullOr(S.String).pipe(T.Body("user_Id"))),
    }),
  ).annotate({
    identifier: "RecordingsGetOneRecordingResponseDataStopReasonCaller",
  }) as any as S.Schema<RecordingsGetOneRecordingResponseDataStopReasonCaller>;

export type RecordingsGetOneRecordingResponseDataStopReasonReason =
  | "API_CALL"
  | "INTERNAL_ERROR"
  | "ALL_PEERS_LEFT";
export const RecordingsGetOneRecordingResponseDataStopReasonReason =
  /*@__PURE__*/ S.String;

export interface RecordingsGetOneRecordingResponseDataStopReason {
  caller?: RecordingsGetOneRecordingResponseDataStopReasonCaller | null;
  /** Specifies the reason why the recording stopped. */
  reason?: RecordingsGetOneRecordingResponseDataStopReasonReason | null;
}
export const RecordingsGetOneRecordingResponseDataStopReason =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      caller: S.optional(
        S.NullOr(RecordingsGetOneRecordingResponseDataStopReasonCaller),
      ),
      reason: S.optional(
        S.NullOr(RecordingsGetOneRecordingResponseDataStopReasonReason),
      ),
    }),
  ).annotate({
    identifier: "RecordingsGetOneRecordingResponseDataStopReason",
  }) as any as S.Schema<RecordingsGetOneRecordingResponseDataStopReason>;

export type RecordingsGetOneRecordingResponseDataStorageConfigType =
  | "aws"
  | "azure"
  | "digitalocean"
  | "gcs"
  | "sftp";
export const RecordingsGetOneRecordingResponseDataStorageConfigType =
  /*@__PURE__*/ S.String;

export type RecordingsGetOneRecordingResponseDataStorageConfigAuthMethod =
  | "KEY"
  | "PASSWORD";
export const RecordingsGetOneRecordingResponseDataStorageConfigAuthMethod =
  /*@__PURE__*/ S.String;

export interface RecordingsGetOneRecordingResponseDataStorageConfig {
  /** Type of storage media. */
  type: RecordingsGetOneRecordingResponseDataStorageConfigType;
  /** Access key of the storage medium. Access key is not required for the `gcs` storage media type. */
  accessKey?: string | null;
  /** Authentication method used for "sftp" type storage medium */
  authMethod?: RecordingsGetOneRecordingResponseDataStorageConfigAuthMethod | null;
  /** Name of the storage medium's bucket. */
  bucket?: string | null;
  /** SSH destination server host for SFTP type storage medium */
  host?: string | null;
  /** SSH destination server password for SFTP type storage medium when auth_method is "PASSWORD". If auth_method is "KEY", this specifies the password for the ssh private key. */
  password?: string | null;
  /** Path relative to the bucket root at which the recording will be placed. */
  path?: string | null;
  /** SSH destination server port for SFTP type storage medium */
  port?: number | null;
  /** Private key used to login to destination SSH server for SFTP type storage medium, when auth_method used is "KEY" */
  privateKey?: string | null;
  /** Region of the storage medium. */
  region?: string | null;
  /** Secret key of the storage medium. Similar to `access_key`, it is only writeable by clients, not readable. */
  secret?: string | null;
  /** SSH destination server username for SFTP type storage medium */
  username?: string | null;
}
export const RecordingsGetOneRecordingResponseDataStorageConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: RecordingsGetOneRecordingResponseDataStorageConfigType,
      accessKey: S.optional(S.NullOr(S.String).pipe(T.Body("access_key"))),
      authMethod: S.optional(
        S.NullOr(
          RecordingsGetOneRecordingResponseDataStorageConfigAuthMethod,
        ).pipe(T.Body("auth_method")),
      ),
      bucket: S.optional(S.NullOr(S.String)),
      host: S.optional(S.NullOr(S.String)),
      password: S.optional(S.NullOr(S.String)),
      path: S.optional(S.NullOr(S.String)),
      port: S.optional(S.NullOr(S.Number)),
      privateKey: S.optional(S.NullOr(S.String).pipe(T.Body("private_key"))),
      region: S.optional(S.NullOr(S.String)),
      secret: S.optional(S.NullOr(S.String)),
      username: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier: "RecordingsGetOneRecordingResponseDataStorageConfig",
  }) as any as S.Schema<RecordingsGetOneRecordingResponseDataStorageConfig>;

export interface RecordingsGetOneRecordingResponseData {
  /** ID of the recording */
  id: string;
  /** If the audio_config is passed, the URL for downloading the audio recording is returned. */
  audioDownloadUrl: string;
  /** URL where the recording can be downloaded. */
  downloadUrl: string;
  /** Timestamp when the download URL expires. */
  downloadUrlExpiry: string;
  /** File size of the recording, in bytes. */
  fileSize: number;
  /** Timestamp when this recording was invoked. */
  invokedTime: string;
  /** File name of the recording. */
  outputFileName: string;
  /** ID of the meeting session this recording is for. */
  sessionId: string;
  /** Timestamp when this recording actually started after being invoked. Usually a few seconds after `invoked_time`. */
  startedTime: string;
  /** Current status of the recording. */
  status: RecordingsGetOneRecordingResponseDataStatus;
  /** Timestamp when this recording was stopped. Optional; is present only when the recording has actually been stopped. */
  stoppedTime: string;
  /** Total recording time in seconds. */
  recordingDuration?: number | null;
  startReason?: RecordingsGetOneRecordingResponseDataStartReason | null;
  stopReason?: RecordingsGetOneRecordingResponseDataStopReason | null;
  storageConfig?: RecordingsGetOneRecordingResponseDataStorageConfig | null;
}
export const RecordingsGetOneRecordingResponseData = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.String,
      audioDownloadUrl: S.String.pipe(T.Body("audio_download_url")),
      downloadUrl: S.String.pipe(T.Body("download_url")),
      downloadUrlExpiry: S.String.pipe(T.Body("download_url_expiry")),
      fileSize: S.Number.pipe(T.Body("file_size")),
      invokedTime: S.String.pipe(T.Body("invoked_time")),
      outputFileName: S.String.pipe(T.Body("output_file_name")),
      sessionId: S.String.pipe(T.Body("session_id")),
      startedTime: S.String.pipe(T.Body("started_time")),
      status: RecordingsGetOneRecordingResponseDataStatus,
      stoppedTime: S.String.pipe(T.Body("stopped_time")),
      recordingDuration: S.optional(
        S.NullOr(S.Number).pipe(T.Body("recording_duration")),
      ),
      startReason: S.optional(
        S.NullOr(RecordingsGetOneRecordingResponseDataStartReason).pipe(
          T.Body("start_reason"),
        ),
      ),
      stopReason: S.optional(
        S.NullOr(RecordingsGetOneRecordingResponseDataStopReason).pipe(
          T.Body("stop_reason"),
        ),
      ),
      storageConfig: S.optional(
        S.NullOr(RecordingsGetOneRecordingResponseDataStorageConfig).pipe(
          T.Body("storage_config"),
        ),
      ),
    }),
).annotate({
  identifier: "RecordingsGetOneRecordingResponseData",
}) as any as S.Schema<RecordingsGetOneRecordingResponseData>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface GetOneRecordingRecordingResponse {
  /** Data returned by the operation */
  data?: RecordingsGetOneRecordingResponseData | null;
}
export const GetOneRecordingRecordingResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    data: S.optional(S.NullOr(RecordingsGetOneRecordingResponseData)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetOneRecordingRecordingResponse",
}) as any as S.Schema<GetOneRecordingRecordingResponse>;

export interface GetOrgAnalyticsAnalyticRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  /** end date in YYYY-MM-DD format */
  endDate?: string;
  /** start date in YYYY-MM-DD format */
  startDate?: string;
}
export const GetOrgAnalyticsAnalyticRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    appId: S.String.pipe(T.Label("app_id")),
    endDate: S.optional(S.String.pipe(T.Query("end_date"))),
    startDate: S.optional(S.String.pipe(T.Query("start_date"))),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/realtime/kit/{app_id}/analytics/daywise",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetOrgAnalyticsAnalyticRequest",
}) as any as S.Schema<GetOrgAnalyticsAnalyticRequest>;

export interface AnalyticsGetOrgAnalyticsResponseDataRecordingStatsDayStatsItem {
  day?: string | null;
  /** Total recording minutes for a specific day */
  totalRecordingMinutes?: number | null;
  /** Total number of recordings for a specific day */
  totalRecordings?: number | null;
}
export const AnalyticsGetOrgAnalyticsResponseDataRecordingStatsDayStatsItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      day: S.optional(S.NullOr(S.String)),
      totalRecordingMinutes: S.optional(
        S.NullOr(S.Number).pipe(T.Body("total_recording_minutes")),
      ),
      totalRecordings: S.optional(
        S.NullOr(S.Number).pipe(T.Body("total_recordings")),
      ),
    }),
  ).annotate({
    identifier:
      "AnalyticsGetOrgAnalyticsResponseDataRecordingStatsDayStatsItem",
  }) as any as S.Schema<AnalyticsGetOrgAnalyticsResponseDataRecordingStatsDayStatsItem>;

export type AnalyticsGetOrgAnalyticsResponseDataRecordingStatsDayStatsList =
  Array<AnalyticsGetOrgAnalyticsResponseDataRecordingStatsDayStatsItem>;
export const AnalyticsGetOrgAnalyticsResponseDataRecordingStatsDayStatsList =
  /*@__PURE__*/ S.Array(
    AnalyticsGetOrgAnalyticsResponseDataRecordingStatsDayStatsItem,
  ) as any as S.Schema<AnalyticsGetOrgAnalyticsResponseDataRecordingStatsDayStatsList>;

export interface AnalyticsGetOrgAnalyticsResponseDataRecordingStats {
  /** Day wise recording stats */
  dayStats?: AnalyticsGetOrgAnalyticsResponseDataRecordingStatsDayStatsList | null;
  /** Total number of recordings during the range specified */
  recordingCount?: number | null;
  /** Total recording minutes during the range specified */
  recordingMinutesConsumed?: number | null;
}
export const AnalyticsGetOrgAnalyticsResponseDataRecordingStats =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      dayStats: S.optional(
        S.NullOr(
          AnalyticsGetOrgAnalyticsResponseDataRecordingStatsDayStatsList,
        ).pipe(T.Body("day_stats")),
      ),
      recordingCount: S.optional(
        S.NullOr(S.Number).pipe(T.Body("recording_count")),
      ),
      recordingMinutesConsumed: S.optional(
        S.NullOr(S.Number).pipe(T.Body("recording_minutes_consumed")),
      ),
    }),
  ).annotate({
    identifier: "AnalyticsGetOrgAnalyticsResponseDataRecordingStats",
  }) as any as S.Schema<AnalyticsGetOrgAnalyticsResponseDataRecordingStats>;

export interface AnalyticsGetOrgAnalyticsResponseDataSessionStatsDayStatsItem {
  day?: string | null;
  /** Total session minutes for a specific day */
  totalSessionMinutes?: number | null;
  /** Total number of sessions for a specific day */
  totalSessions?: number | null;
}
export const AnalyticsGetOrgAnalyticsResponseDataSessionStatsDayStatsItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      day: S.optional(S.NullOr(S.String)),
      totalSessionMinutes: S.optional(
        S.NullOr(S.Number).pipe(T.Body("total_session_minutes")),
      ),
      totalSessions: S.optional(
        S.NullOr(S.Number).pipe(T.Body("total_sessions")),
      ),
    }),
  ).annotate({
    identifier: "AnalyticsGetOrgAnalyticsResponseDataSessionStatsDayStatsItem",
  }) as any as S.Schema<AnalyticsGetOrgAnalyticsResponseDataSessionStatsDayStatsItem>;

export type AnalyticsGetOrgAnalyticsResponseDataSessionStatsDayStatsList =
  Array<AnalyticsGetOrgAnalyticsResponseDataSessionStatsDayStatsItem>;
export const AnalyticsGetOrgAnalyticsResponseDataSessionStatsDayStatsList =
  /*@__PURE__*/ S.Array(
    AnalyticsGetOrgAnalyticsResponseDataSessionStatsDayStatsItem,
  ) as any as S.Schema<AnalyticsGetOrgAnalyticsResponseDataSessionStatsDayStatsList>;

export interface AnalyticsGetOrgAnalyticsResponseDataSessionStats {
  /** Day wise session stats */
  dayStats?: AnalyticsGetOrgAnalyticsResponseDataSessionStatsDayStatsList | null;
  /** Total number of sessions during the range specified */
  sessionsCount?: number | null;
  /** Total session minutes during the range specified */
  sessionsMinutesConsumed?: number | null;
}
export const AnalyticsGetOrgAnalyticsResponseDataSessionStats =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      dayStats: S.optional(
        S.NullOr(
          AnalyticsGetOrgAnalyticsResponseDataSessionStatsDayStatsList,
        ).pipe(T.Body("day_stats")),
      ),
      sessionsCount: S.optional(
        S.NullOr(S.Number).pipe(T.Body("sessions_count")),
      ),
      sessionsMinutesConsumed: S.optional(
        S.NullOr(S.Number).pipe(T.Body("sessions_minutes_consumed")),
      ),
    }),
  ).annotate({
    identifier: "AnalyticsGetOrgAnalyticsResponseDataSessionStats",
  }) as any as S.Schema<AnalyticsGetOrgAnalyticsResponseDataSessionStats>;

export interface AnalyticsGetOrgAnalyticsResponseData {
  /** Recording statistics of an App during the range specified */
  recordingStats?: AnalyticsGetOrgAnalyticsResponseDataRecordingStats | null;
  /** Session statistics of an App during the range specified */
  sessionStats?: AnalyticsGetOrgAnalyticsResponseDataSessionStats | null;
}
export const AnalyticsGetOrgAnalyticsResponseData = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      recordingStats: S.optional(
        S.NullOr(AnalyticsGetOrgAnalyticsResponseDataRecordingStats).pipe(
          T.Body("recording_stats"),
        ),
      ),
      sessionStats: S.optional(
        S.NullOr(AnalyticsGetOrgAnalyticsResponseDataSessionStats).pipe(
          T.Body("session_stats"),
        ),
      ),
    }),
).annotate({
  identifier: "AnalyticsGetOrgAnalyticsResponseData",
}) as any as S.Schema<AnalyticsGetOrgAnalyticsResponseData>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface GetOrgAnalyticsAnalyticResponse {
  data?: AnalyticsGetOrgAnalyticsResponseData | null;
}
export const GetOrgAnalyticsAnalyticResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    data: S.optional(S.NullOr(AnalyticsGetOrgAnalyticsResponseData)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetOrgAnalyticsAnalyticResponse",
}) as any as S.Schema<GetOrgAnalyticsAnalyticResponse>;

export type SessionsGetParticipantDataFromPeerIdRequestFilters =
  | "device_info"
  | "ip_information"
  | "precall_network_information"
  | "events"
  | "quality_stats";
export const SessionsGetParticipantDataFromPeerIdRequestFilters =
  /*@__PURE__*/ S.String;

export interface GetParticipantDataFromPeerIdSessionRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  peerId: string;
  /** Filter to apply to the peer report. */
  filters?: SessionsGetParticipantDataFromPeerIdRequestFilters | (string & {});
  /** if true, response includes all the peer events of participant. */
  includePeerEvents?: boolean;
}
export const GetParticipantDataFromPeerIdSessionRequest =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      accountId: S.String.pipe(T.Label("account_id")),
      appId: S.String.pipe(T.Label("app_id")),
      peerId: S.String.pipe(T.Label("peer_id")),
      filters: S.optional(
        SessionsGetParticipantDataFromPeerIdRequestFilters.pipe(T.Query()),
      ),
      includePeerEvents: S.optional(
        S.Boolean.pipe(T.Query("include_peer_events")),
      ),
    })
      .pipe(
        T.Http({
          method: "GET",
          uri: "/accounts/{account_id}/realtime/kit/{app_id}/sessions/peer-report/{peer_id}",
          code: 200,
        }),
      )
      .pipe(T.KeyDictionary(KEY_DICTIONARY)),
  ).annotate({
    identifier: "GetParticipantDataFromPeerIdSessionRequest",
  }) as any as S.Schema<GetParticipantDataFromPeerIdSessionRequest>;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerEventsItemEventName =
  | "PEER_CREATED"
  | "PEER_JOINING"
  | "PEER_LEAVING";
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerEventsItemEventName =
  /*@__PURE__*/ S.String;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerEventsItemPresetViewType =
  | "GROUP_CALL"
  | "WEBINAR"
  | "AUDIO_ROOM"
  | "LIVESTREAM"
  | "CHAT";
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerEventsItemPresetViewType =
  /*@__PURE__*/ S.String;

export interface SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerEventsItem {
  /** ID of the peer event. */
  id?: string | null;
  /** Timestamp when this peer event was created. */
  createdAt?: string | null;
  /** Name of the peer event. */
  eventName?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerEventsItemEventName | null;
  /** Minutes consumed attributed to this event. */
  minutesConsumed?: number | null;
  /** ID of the participant this event belongs to. */
  participantId?: string | null;
  /** Peer ID this event belongs to. */
  peerId?: string | null;
  /** View type of the preset associated with the peer. */
  presetViewType?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerEventsItemPresetViewType | null;
  /** ID of the session this event belongs to. */
  sessionId?: string | null;
  /** ID of the socket session associated with this event. */
  socketSessionId?: string | null;
  /** Timestamp when this peer event was last updated. */
  updatedAt?: string | null;
}
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerEventsItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.optional(S.NullOr(S.String)),
      createdAt: S.optional(S.NullOr(S.String).pipe(T.Body("created_at"))),
      eventName: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerEventsItemEventName,
        ).pipe(T.Body("event_name")),
      ),
      minutesConsumed: S.optional(
        S.NullOr(S.Number).pipe(T.Body("minutes_consumed")),
      ),
      participantId: S.optional(
        S.NullOr(S.String).pipe(T.Body("participant_id")),
      ),
      peerId: S.optional(S.NullOr(S.String).pipe(T.Body("peer_id"))),
      presetViewType: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerEventsItemPresetViewType,
        ).pipe(T.Body("preset_view_type")),
      ),
      sessionId: S.optional(S.NullOr(S.String).pipe(T.Body("session_id"))),
      socketSessionId: S.optional(
        S.NullOr(S.String).pipe(T.Body("socket_session_id")),
      ),
      updatedAt: S.optional(S.NullOr(S.String).pipe(T.Body("updated_at"))),
    }),
  ).annotate({
    identifier:
      "SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerEventsItem",
  }) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerEventsItem>;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerEventsList =
  Array<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerEventsItem>;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerEventsList =
  /*@__PURE__*/ S.Array(
    SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerEventsItem,
  ) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerEventsList>;

export interface SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesItemAddedItem {
  /** ID of the device. */
  deviceId?: string | null;
  /** Kind of device, for example audioinput or videoinput. */
  kind?: string | null;
  /** Human-readable label of the device. */
  label?: string | null;
}
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesItemAddedItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      deviceId: S.optional(S.NullOr(S.String).pipe(T.Body("device_id"))),
      kind: S.optional(S.NullOr(S.String)),
      label: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier:
      "SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesItemAddedItem",
  }) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesItemAddedItem>;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesItemAddedList =
  Array<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesItemAddedItem>;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesItemAddedList =
  /*@__PURE__*/ S.Array(
    SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesItemAddedItem,
  ) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesItemAddedList>;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesItemRemovedItem =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesItemAddedItem;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesItemRemovedItem =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesItemAddedItem;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesItemRemovedList =
  Array<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesItemAddedItem>;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesItemRemovedList =
  /*@__PURE__*/ S.Array(
    SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesItemAddedItem,
  ) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesItemRemovedList>;

export interface SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesItem {
  /** Devices that became available. */
  added?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesItemAddedList | null;
  /** Devices that became unavailable. */
  removed?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesItemRemovedList | null;
  /** Timestamp of the device update. */
  timestamp?: string | null;
}
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      added: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesItemAddedList,
        ),
      ),
      removed: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesItemRemovedList,
        ),
      ),
      timestamp: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier:
      "SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesItem",
  }) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesItem>;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesList =
  Array<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesItem>;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesList =
  /*@__PURE__*/ S.Array(
    SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesItem,
  ) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesList>;

export interface SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataBrowserMetadata {
  browser?: string | null;
  browserVersion?: string | null;
  engine?: string | null;
  userAgent?: string | null;
  webglSupport?: boolean | null;
}
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataBrowserMetadata =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      browser: S.optional(S.NullOr(S.String)),
      browserVersion: S.optional(
        S.NullOr(S.String).pipe(T.Body("browser_version")),
      ),
      engine: S.optional(S.NullOr(S.String)),
      userAgent: S.optional(S.NullOr(S.String).pipe(T.Body("user_agent"))),
      webglSupport: S.optional(
        S.NullOr(S.Boolean).pipe(T.Body("webgl_support")),
      ),
    }),
  ).annotate({
    identifier:
      "SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataBrowserMetadata",
  }) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataBrowserMetadata>;

export interface SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataCandidatePairsConsumingTransportItem {
  availableIncomingBitrate?: number | null;
  availableOutgoingBitrate?: number | null;
  bytesDiscardedOnSend?: number | null;
  bytesReceived?: number | null;
  bytesSent?: number | null;
  currentRoundTripTime?: number | null;
  /** Epoch milliseconds when the last packet was received. */
  lastPacketReceivedTimestamp?: number | null;
  /** Epoch milliseconds when the last packet was sent. */
  lastPacketSentTimestamp?: number | null;
  localCandidateAddress?: string | null;
  localCandidateId?: string | null;
  localCandidateNetworkType?: string | null;
  localCandidatePort?: number | null;
  localCandidateProtocol?: string | null;
  localCandidateRelatedAddress?: string | null;
  localCandidateRelatedPort?: number | null;
  localCandidateType?: string | null;
  localCandidateUrl?: string | null;
  nominated?: boolean | null;
  packetsDiscardedOnSend?: number | null;
  packetsReceived?: number | null;
  packetsSent?: number | null;
  remoteCandidateAddress?: string | null;
  remoteCandidateId?: string | null;
  remoteCandidatePort?: number | null;
  remoteCandidateProtocol?: string | null;
  remoteCandidateType?: string | null;
  remoteCandidateUrl?: string | null;
  totalRoundTripTime?: number | null;
}
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataCandidatePairsConsumingTransportItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      availableIncomingBitrate: S.optional(
        S.NullOr(S.Number).pipe(T.Body("available_incoming_bitrate")),
      ),
      availableOutgoingBitrate: S.optional(
        S.NullOr(S.Number).pipe(T.Body("available_outgoing_bitrate")),
      ),
      bytesDiscardedOnSend: S.optional(
        S.NullOr(S.Number).pipe(T.Body("bytes_discarded_on_send")),
      ),
      bytesReceived: S.optional(
        S.NullOr(S.Number).pipe(T.Body("bytes_received")),
      ),
      bytesSent: S.optional(S.NullOr(S.Number).pipe(T.Body("bytes_sent"))),
      currentRoundTripTime: S.optional(
        S.NullOr(S.Number).pipe(T.Body("current_round_trip_time")),
      ),
      lastPacketReceivedTimestamp: S.optional(
        S.NullOr(S.Number).pipe(T.Body("last_packet_received_timestamp")),
      ),
      lastPacketSentTimestamp: S.optional(
        S.NullOr(S.Number).pipe(T.Body("last_packet_sent_timestamp")),
      ),
      localCandidateAddress: S.optional(
        S.NullOr(S.String).pipe(T.Body("local_candidate_address")),
      ),
      localCandidateId: S.optional(
        S.NullOr(S.String).pipe(T.Body("local_candidate_id")),
      ),
      localCandidateNetworkType: S.optional(
        S.NullOr(S.String).pipe(T.Body("local_candidate_network_type")),
      ),
      localCandidatePort: S.optional(
        S.NullOr(S.Number).pipe(T.Body("local_candidate_port")),
      ),
      localCandidateProtocol: S.optional(
        S.NullOr(S.String).pipe(T.Body("local_candidate_protocol")),
      ),
      localCandidateRelatedAddress: S.optional(
        S.NullOr(S.String).pipe(T.Body("local_candidate_related_address")),
      ),
      localCandidateRelatedPort: S.optional(
        S.NullOr(S.Number).pipe(T.Body("local_candidate_related_port")),
      ),
      localCandidateType: S.optional(
        S.NullOr(S.String).pipe(T.Body("local_candidate_type")),
      ),
      localCandidateUrl: S.optional(
        S.NullOr(S.String).pipe(T.Body("local_candidate_url")),
      ),
      nominated: S.optional(S.NullOr(S.Boolean)),
      packetsDiscardedOnSend: S.optional(
        S.NullOr(S.Number).pipe(T.Body("packets_discarded_on_send")),
      ),
      packetsReceived: S.optional(
        S.NullOr(S.Number).pipe(T.Body("packets_received")),
      ),
      packetsSent: S.optional(S.NullOr(S.Number).pipe(T.Body("packets_sent"))),
      remoteCandidateAddress: S.optional(
        S.NullOr(S.String).pipe(T.Body("remote_candidate_address")),
      ),
      remoteCandidateId: S.optional(
        S.NullOr(S.String).pipe(T.Body("remote_candidate_id")),
      ),
      remoteCandidatePort: S.optional(
        S.NullOr(S.Number).pipe(T.Body("remote_candidate_port")),
      ),
      remoteCandidateProtocol: S.optional(
        S.NullOr(S.String).pipe(T.Body("remote_candidate_protocol")),
      ),
      remoteCandidateType: S.optional(
        S.NullOr(S.String).pipe(T.Body("remote_candidate_type")),
      ),
      remoteCandidateUrl: S.optional(
        S.NullOr(S.String).pipe(T.Body("remote_candidate_url")),
      ),
      totalRoundTripTime: S.optional(
        S.NullOr(S.Number).pipe(T.Body("total_round_trip_time")),
      ),
    }),
  ).annotate({
    identifier:
      "SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataCandidatePairsConsumingTransportItem",
  }) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataCandidatePairsConsumingTransportItem>;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataCandidatePairsConsumingTransportList =
  Array<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataCandidatePairsConsumingTransportItem>;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataCandidatePairsConsumingTransportList =
  /*@__PURE__*/ S.Array(
    SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataCandidatePairsConsumingTransportItem,
  ) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataCandidatePairsConsumingTransportList>;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataCandidatePairsProducingTransportItem =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataCandidatePairsConsumingTransportItem;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataCandidatePairsProducingTransportItem =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataCandidatePairsConsumingTransportItem;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataCandidatePairsProducingTransportList =
  Array<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataCandidatePairsConsumingTransportItem>;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataCandidatePairsProducingTransportList =
  /*@__PURE__*/ S.Array(
    SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataCandidatePairsConsumingTransportItem,
  ) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataCandidatePairsProducingTransportList>;

export interface SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataCandidatePairs {
  consumingTransport?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataCandidatePairsConsumingTransportList | null;
  producingTransport?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataCandidatePairsProducingTransportList | null;
}
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataCandidatePairs =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      consumingTransport: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataCandidatePairsConsumingTransportList,
        ).pipe(T.Body("consuming_transport")),
      ),
      producingTransport: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataCandidatePairsProducingTransportList,
        ).pipe(T.Body("producing_transport")),
      ),
    }),
  ).annotate({
    identifier:
      "SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataCandidatePairs",
  }) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataCandidatePairs>;

export interface SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataDeviceInfo {
  cpus?: number | null;
  isMobile?: boolean | null;
  os?: string | null;
  osVersion?: string | null;
}
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataDeviceInfo =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      cpus: S.optional(S.NullOr(S.Number)),
      isMobile: S.optional(S.NullOr(S.Boolean).pipe(T.Body("is_mobile"))),
      os: S.optional(S.NullOr(S.String)),
      osVersion: S.optional(S.NullOr(S.String).pipe(T.Body("os_version"))),
    }),
  ).annotate({
    identifier:
      "SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataDeviceInfo",
  }) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataDeviceInfo>;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataEventsItemMetadata =
  | string
  | number
  | boolean;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataEventsItemMetadata =
  /*@__PURE__*/ S.Unknown.pipe(T.UnionCases([[], [], []]));

export interface SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataEventsItem {
  /** Event-specific metadata. Keys vary per event; values are primitive scalars (string, number, boolean, or null). */
  metadata?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataEventsItemMetadata | null;
  /** Name of the event. */
  name?: string | null;
  /** Timestamp when the event occurred. */
  timestamp?: string | null;
}
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataEventsItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      metadata: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataEventsItemMetadata,
        ),
      ),
      name: S.optional(S.NullOr(S.String)),
      timestamp: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier:
      "SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataEventsItem",
  }) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataEventsItem>;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataEventsList =
  Array<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataEventsItem>;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataEventsList =
  /*@__PURE__*/ S.Array(
    SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataEventsItem,
  ) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataEventsList>;

export interface SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataIpInformationAsn {
  asn?: string | null;
  domain?: string | null;
  name?: string | null;
  route?: string | null;
  type?: string | null;
}
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataIpInformationAsn =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      asn: S.optional(S.NullOr(S.String)),
      domain: S.optional(S.NullOr(S.String)),
      name: S.optional(S.NullOr(S.String)),
      route: S.optional(S.NullOr(S.String)),
      type: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier:
      "SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataIpInformationAsn",
  }) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataIpInformationAsn>;

export interface SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataIpInformation {
  asn?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataIpInformationAsn | null;
  city?: string | null;
  country?: string | null;
  ipv4?: string | null;
  org?: string | null;
  region?: string | null;
  timezone?: string | null;
}
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataIpInformation =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      asn: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataIpInformationAsn,
        ),
      ),
      city: S.optional(S.NullOr(S.String)),
      country: S.optional(S.NullOr(S.String)),
      ipv4: S.optional(S.NullOr(S.String)),
      org: S.optional(S.NullOr(S.String)),
      region: S.optional(S.NullOr(S.String)),
      timezone: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier:
      "SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataIpInformation",
  }) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataIpInformation>;

export interface SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataNativeMetadata {
  audioEncoder?: string | null;
  videoEncoder?: string | null;
}
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataNativeMetadata =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      audioEncoder: S.optional(
        S.NullOr(S.String).pipe(T.Body("audio_encoder")),
      ),
      videoEncoder: S.optional(
        S.NullOr(S.String).pipe(T.Body("video_encoder")),
      ),
    }),
  ).annotate({
    identifier:
      "SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataNativeMetadata",
  }) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataNativeMetadata>;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataPcMetadataItemSdpList =
  Array<string>;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataPcMetadataItemSdpList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataPcMetadataItemSdpList>;

export interface SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataPcMetadataItem {
  effectiveNetworkType?: string | null;
  reflexiveConnectivity?: boolean | null;
  relayConnectivity?: boolean | null;
  sdp?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataPcMetadataItemSdpList | null;
  timestamp?: string | null;
  turnConnectivity?: boolean | null;
}
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataPcMetadataItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      effectiveNetworkType: S.optional(
        S.NullOr(S.String).pipe(T.Body("effective_network_type")),
      ),
      reflexiveConnectivity: S.optional(
        S.NullOr(S.Boolean).pipe(T.Body("reflexive_connectivity")),
      ),
      relayConnectivity: S.optional(
        S.NullOr(S.Boolean).pipe(T.Body("relay_connectivity")),
      ),
      sdp: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataPcMetadataItemSdpList,
        ),
      ),
      timestamp: S.optional(S.NullOr(S.String)),
      turnConnectivity: S.optional(
        S.NullOr(S.Boolean).pipe(T.Body("turn_connectivity")),
      ),
    }),
  ).annotate({
    identifier:
      "SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataPcMetadataItem",
  }) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataPcMetadataItem>;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataPcMetadataList =
  Array<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataPcMetadataItem>;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataPcMetadataList =
  /*@__PURE__*/ S.Array(
    SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataPcMetadataItem,
  ) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataPcMetadataList>;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataSelectedDeviceUpdatesItemDevice =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesItemAddedItem;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataSelectedDeviceUpdatesItemDevice =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesItemAddedItem;

export interface SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataSelectedDeviceUpdatesItem {
  /** A media device (camera, microphone, or speaker). */
  device?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesItemAddedItem | null;
  timestamp?: string | null;
}
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataSelectedDeviceUpdatesItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      device: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesItemAddedItem,
        ),
      ),
      timestamp: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier:
      "SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataSelectedDeviceUpdatesItem",
  }) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataSelectedDeviceUpdatesItem>;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataSelectedDeviceUpdatesList =
  Array<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataSelectedDeviceUpdatesItem>;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataSelectedDeviceUpdatesList =
  /*@__PURE__*/ S.Array(
    SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataSelectedDeviceUpdatesItem,
  ) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataSelectedDeviceUpdatesList>;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataSpeakerDevicesUpdatesItemAddedItem =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesItemAddedItem;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataSpeakerDevicesUpdatesItemAddedItem =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesItemAddedItem;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataSpeakerDevicesUpdatesItemAddedList =
  Array<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesItemAddedItem>;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataSpeakerDevicesUpdatesItemAddedList =
  /*@__PURE__*/ S.Array(
    SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesItemAddedItem,
  ) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataSpeakerDevicesUpdatesItemAddedList>;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataSpeakerDevicesUpdatesItemRemovedItem =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesItemAddedItem;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataSpeakerDevicesUpdatesItemRemovedItem =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesItemAddedItem;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataSpeakerDevicesUpdatesItemRemovedList =
  Array<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesItemAddedItem>;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataSpeakerDevicesUpdatesItemRemovedList =
  /*@__PURE__*/ S.Array(
    SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesItemAddedItem,
  ) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataSpeakerDevicesUpdatesItemRemovedList>;

export interface SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataSpeakerDevicesUpdatesItem {
  /** Devices that became available. */
  added?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataSpeakerDevicesUpdatesItemAddedList | null;
  /** Devices that became unavailable. */
  removed?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataSpeakerDevicesUpdatesItemRemovedList | null;
  /** Timestamp of the device update. */
  timestamp?: string | null;
}
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataSpeakerDevicesUpdatesItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      added: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataSpeakerDevicesUpdatesItemAddedList,
        ),
      ),
      removed: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataSpeakerDevicesUpdatesItemRemovedList,
        ),
      ),
      timestamp: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier:
      "SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataSpeakerDevicesUpdatesItem",
  }) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataSpeakerDevicesUpdatesItem>;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataSpeakerDevicesUpdatesList =
  Array<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataSpeakerDevicesUpdatesItem>;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataSpeakerDevicesUpdatesList =
  /*@__PURE__*/ S.Array(
    SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataSpeakerDevicesUpdatesItem,
  ) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataSpeakerDevicesUpdatesList>;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataVideoDevicesUpdatesItemAddedItem =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesItemAddedItem;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataVideoDevicesUpdatesItemAddedItem =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesItemAddedItem;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataVideoDevicesUpdatesItemAddedList =
  Array<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesItemAddedItem>;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataVideoDevicesUpdatesItemAddedList =
  /*@__PURE__*/ S.Array(
    SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesItemAddedItem,
  ) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataVideoDevicesUpdatesItemAddedList>;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataVideoDevicesUpdatesItemRemovedItem =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesItemAddedItem;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataVideoDevicesUpdatesItemRemovedItem =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesItemAddedItem;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataVideoDevicesUpdatesItemRemovedList =
  Array<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesItemAddedItem>;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataVideoDevicesUpdatesItemRemovedList =
  /*@__PURE__*/ S.Array(
    SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesItemAddedItem,
  ) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataVideoDevicesUpdatesItemRemovedList>;

export interface SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataVideoDevicesUpdatesItem {
  /** Devices that became available. */
  added?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataVideoDevicesUpdatesItemAddedList | null;
  /** Devices that became unavailable. */
  removed?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataVideoDevicesUpdatesItemRemovedList | null;
  /** Timestamp of the device update. */
  timestamp?: string | null;
}
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataVideoDevicesUpdatesItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      added: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataVideoDevicesUpdatesItemAddedList,
        ),
      ),
      removed: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataVideoDevicesUpdatesItemRemovedList,
        ),
      ),
      timestamp: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier:
      "SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataVideoDevicesUpdatesItem",
  }) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataVideoDevicesUpdatesItem>;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataVideoDevicesUpdatesList =
  Array<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataVideoDevicesUpdatesItem>;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataVideoDevicesUpdatesList =
  /*@__PURE__*/ S.Array(
    SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataVideoDevicesUpdatesItem,
  ) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataVideoDevicesUpdatesList>;

export interface SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadata {
  audioDevicesUpdates?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesList | null;
  browserMetadata?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataBrowserMetadata | null;
  candidatePairs?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataCandidatePairs | null;
  deviceInfo?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataDeviceInfo | null;
  events?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataEventsList | null;
  ipInformation?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataIpInformation | null;
  nativeMetadata?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataNativeMetadata | null;
  pcMetadata?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataPcMetadataList | null;
  roomViewType?: string | null;
  sdkName?: string | null;
  sdkType?: string | null;
  sdkVersion?: string | null;
  selectedDeviceUpdates?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataSelectedDeviceUpdatesList | null;
  speakerDevicesUpdates?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataSpeakerDevicesUpdatesList | null;
  videoDevicesUpdates?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataVideoDevicesUpdatesList | null;
}
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadata =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      audioDevicesUpdates: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataAudioDevicesUpdatesList,
        ).pipe(T.Body("audio_devices_updates")),
      ),
      browserMetadata: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataBrowserMetadata,
        ).pipe(T.Body("browser_metadata")),
      ),
      candidatePairs: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataCandidatePairs,
        ).pipe(T.Body("candidate_pairs")),
      ),
      deviceInfo: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataDeviceInfo,
        ).pipe(T.Body("device_info")),
      ),
      events: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataEventsList,
        ),
      ),
      ipInformation: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataIpInformation,
        ).pipe(T.Body("ip_information")),
      ),
      nativeMetadata: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataNativeMetadata,
        ).pipe(T.Body("native_metadata")),
      ),
      pcMetadata: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataPcMetadataList,
        ).pipe(T.Body("pc_metadata")),
      ),
      roomViewType: S.optional(
        S.NullOr(S.String).pipe(T.Body("room_view_type")),
      ),
      sdkName: S.optional(S.NullOr(S.String).pipe(T.Body("sdk_name"))),
      sdkType: S.optional(S.NullOr(S.String).pipe(T.Body("sdk_type"))),
      sdkVersion: S.optional(S.NullOr(S.String).pipe(T.Body("sdk_version"))),
      selectedDeviceUpdates: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataSelectedDeviceUpdatesList,
        ).pipe(T.Body("selected_device_updates")),
      ),
      speakerDevicesUpdates: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataSpeakerDevicesUpdatesList,
        ).pipe(T.Body("speaker_devices_updates")),
      ),
      videoDevicesUpdates: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadataVideoDevicesUpdatesList,
        ).pipe(T.Body("video_devices_updates")),
      ),
    }),
  ).annotate({
    identifier:
      "SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadata",
  }) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadata>;

export interface SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerItem {
  bytesReceived?: number | null;
  concealmentEvents?: number | null;
  consumerId?: string | null;
  jitter?: number | null;
  jitterBufferDelay?: number | null;
  jitterBufferEmittedCount?: number | null;
  mid?: string | null;
  mosQuality?: number | null;
  packetsLost?: number | null;
  packetsReceived?: number | null;
  peerId?: string | null;
  producerId?: string | null;
  ssrc?: number | null;
  timestamp?: string | null;
}
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      bytesReceived: S.optional(
        S.NullOr(S.Number).pipe(T.Body("bytes_received")),
      ),
      concealmentEvents: S.optional(
        S.NullOr(S.Number).pipe(T.Body("concealment_events")),
      ),
      consumerId: S.optional(S.NullOr(S.String).pipe(T.Body("consumer_id"))),
      jitter: S.optional(S.NullOr(S.Number)),
      jitterBufferDelay: S.optional(
        S.NullOr(S.Number).pipe(T.Body("jitter_buffer_delay")),
      ),
      jitterBufferEmittedCount: S.optional(
        S.NullOr(S.Number).pipe(T.Body("jitter_buffer_emitted_count")),
      ),
      mid: S.optional(S.NullOr(S.String)),
      mosQuality: S.optional(S.NullOr(S.Number).pipe(T.Body("mos_quality"))),
      packetsLost: S.optional(S.NullOr(S.Number).pipe(T.Body("packets_lost"))),
      packetsReceived: S.optional(
        S.NullOr(S.Number).pipe(T.Body("packets_received")),
      ),
      peerId: S.optional(S.NullOr(S.String).pipe(T.Body("peer_id"))),
      producerId: S.optional(S.NullOr(S.String).pipe(T.Body("producer_id"))),
      ssrc: S.optional(S.NullOr(S.Number)),
      timestamp: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier:
      "SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerItem",
  }) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerItem>;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerList =
  Array<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerItem>;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerList =
  /*@__PURE__*/ S.Array(
    SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerItem,
  ) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerList>;

export interface SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeJitterBufferDelay {
  "100msOrGreaterEventFraction"?: number | null;
  "250msOrGreaterEventFraction"?: number | null;
  "500msOrGreaterEventFraction"?: number | null;
  avg?: number | null;
}
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeJitterBufferDelay =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      "100msOrGreaterEventFraction": S.optional(
        S.NullOr(S.Number).pipe(T.Body("100ms_or_greater_event_fraction")),
      ),
      "250msOrGreaterEventFraction": S.optional(
        S.NullOr(S.Number).pipe(T.Body("250ms_or_greater_event_fraction")),
      ),
      "500msOrGreaterEventFraction": S.optional(
        S.NullOr(S.Number).pipe(T.Body("500ms_or_greater_event_fraction")),
      ),
      avg: S.optional(S.NullOr(S.Number)),
    }),
  ).annotate({
    identifier:
      "SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeJitterBufferDelay",
  }) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeJitterBufferDelay>;

export interface SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativePacketLoss {
  "10OrGreaterEventFraction"?: number | null;
  "25OrGreaterEventFraction"?: number | null;
  "5OrGreaterEventFraction"?: number | null;
  "50OrGreaterEventFraction"?: number | null;
  avg?: number | null;
}
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativePacketLoss =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      "10OrGreaterEventFraction": S.optional(
        S.NullOr(S.Number).pipe(T.Body("10_or_greater_event_fraction")),
      ),
      "25OrGreaterEventFraction": S.optional(
        S.NullOr(S.Number).pipe(T.Body("25_or_greater_event_fraction")),
      ),
      "5OrGreaterEventFraction": S.optional(
        S.NullOr(S.Number).pipe(T.Body("5_or_greater_event_fraction")),
      ),
      "50OrGreaterEventFraction": S.optional(
        S.NullOr(S.Number).pipe(T.Body("50_or_greater_event_fraction")),
      ),
      avg: S.optional(S.NullOr(S.Number)),
    }),
  ).annotate({
    identifier:
      "SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativePacketLoss",
  }) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativePacketLoss>;

export interface SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos {
  avg?: number | null;
  p50?: number | null;
  p75?: number | null;
  p90?: number | null;
}
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      avg: S.optional(S.NullOr(S.Number)),
      p50: S.optional(S.NullOr(S.Number)),
      p75: S.optional(S.NullOr(S.Number)),
      p90: S.optional(S.NullOr(S.Number)),
    }),
  ).annotate({
    identifier:
      "SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos",
  }) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos>;

export interface SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulative {
  /** Cumulative latency distribution (milliseconds-based thresholds). */
  jitterBufferDelay?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeJitterBufferDelay | null;
  /** Cumulative packet loss distribution. */
  packetLoss?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativePacketLoss | null;
  /** Distribution summary with average and percentiles. */
  qualityMos?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos | null;
}
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulative =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      jitterBufferDelay: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeJitterBufferDelay,
        ).pipe(T.Body("jitter_buffer_delay")),
      ),
      packetLoss: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativePacketLoss,
        ).pipe(T.Body("packet_loss")),
      ),
      qualityMos: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos,
        ).pipe(T.Body("quality_mos")),
      ),
    }),
  ).annotate({
    identifier:
      "SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulative",
  }) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulative>;

export interface SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioProducerItem {
  bytesSent?: number | null;
  jitter?: number | null;
  mid?: string | null;
  mosQuality?: number | null;
  packetsLost?: number | null;
  packetsSent?: number | null;
  producerId?: string | null;
  rtt?: number | null;
  ssrc?: number | null;
  timestamp?: string | null;
}
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioProducerItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      bytesSent: S.optional(S.NullOr(S.Number).pipe(T.Body("bytes_sent"))),
      jitter: S.optional(S.NullOr(S.Number)),
      mid: S.optional(S.NullOr(S.String)),
      mosQuality: S.optional(S.NullOr(S.Number).pipe(T.Body("mos_quality"))),
      packetsLost: S.optional(S.NullOr(S.Number).pipe(T.Body("packets_lost"))),
      packetsSent: S.optional(S.NullOr(S.Number).pipe(T.Body("packets_sent"))),
      producerId: S.optional(S.NullOr(S.String).pipe(T.Body("producer_id"))),
      rtt: S.optional(S.NullOr(S.Number)),
      ssrc: S.optional(S.NullOr(S.Number)),
      timestamp: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier:
      "SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioProducerItem",
  }) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioProducerItem>;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioProducerList =
  Array<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioProducerItem>;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioProducerList =
  /*@__PURE__*/ S.Array(
    SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioProducerItem,
  ) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioProducerList>;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioProducerCumulativePacketLoss =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativePacketLoss;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioProducerCumulativePacketLoss =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativePacketLoss;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioProducerCumulativeQualityMos =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioProducerCumulativeQualityMos =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioProducerCumulativeRtt =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeJitterBufferDelay;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioProducerCumulativeRtt =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeJitterBufferDelay;

export interface SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioProducerCumulative {
  /** Cumulative packet loss distribution. */
  packetLoss?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativePacketLoss | null;
  /** Distribution summary with average and percentiles. */
  qualityMos?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos | null;
  /** Cumulative latency distribution (milliseconds-based thresholds). */
  rtt?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeJitterBufferDelay | null;
}
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioProducerCumulative =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      packetLoss: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativePacketLoss,
        ).pipe(T.Body("packet_loss")),
      ),
      qualityMos: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos,
        ).pipe(T.Body("quality_mos")),
      ),
      rtt: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeJitterBufferDelay,
        ),
      ),
    }),
  ).annotate({
    identifier:
      "SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioProducerCumulative",
  }) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioProducerCumulative>;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareAudioConsumerItem =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerItem;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareAudioConsumerItem =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerItem;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareAudioConsumerList =
  Array<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerItem>;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareAudioConsumerList =
  /*@__PURE__*/ S.Array(
    SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerItem,
  ) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareAudioConsumerList>;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareAudioConsumerCumulativeJitterBufferDelay =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeJitterBufferDelay;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareAudioConsumerCumulativeJitterBufferDelay =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeJitterBufferDelay;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareAudioConsumerCumulativePacketLoss =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativePacketLoss;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareAudioConsumerCumulativePacketLoss =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativePacketLoss;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareAudioConsumerCumulativeQualityMos =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareAudioConsumerCumulativeQualityMos =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareAudioConsumerCumulative =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulative;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareAudioConsumerCumulative =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulative;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareAudioProducerItem =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioProducerItem;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareAudioProducerItem =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioProducerItem;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareAudioProducerList =
  Array<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioProducerItem>;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareAudioProducerList =
  /*@__PURE__*/ S.Array(
    SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioProducerItem,
  ) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareAudioProducerList>;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareAudioProducerCumulativePacketLoss =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativePacketLoss;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareAudioProducerCumulativePacketLoss =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativePacketLoss;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareAudioProducerCumulativeQualityMos =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareAudioProducerCumulativeQualityMos =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareAudioProducerCumulativeRtt =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeJitterBufferDelay;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareAudioProducerCumulativeRtt =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeJitterBufferDelay;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareAudioProducerCumulative =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioProducerCumulative;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareAudioProducerCumulative =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioProducerCumulative;

export interface SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoConsumerItem {
  bytesReceived?: number | null;
  consumerId?: string | null;
  firCount?: number | null;
  frameHeight?: number | null;
  frameWidth?: number | null;
  framesDecoded?: number | null;
  framesDropped?: number | null;
  framesPerSecond?: number | null;
  jitter?: number | null;
  jitterBufferDelay?: number | null;
  jitterBufferEmittedCount?: number | null;
  keyFramesDecoded?: number | null;
  mid?: string | null;
  mosQuality?: number | null;
  packetsLost?: number | null;
  packetsReceived?: number | null;
  peerId?: string | null;
  producerId?: string | null;
  ssrc?: number | null;
  timestamp?: string | null;
}
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoConsumerItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      bytesReceived: S.optional(
        S.NullOr(S.Number).pipe(T.Body("bytes_received")),
      ),
      consumerId: S.optional(S.NullOr(S.String).pipe(T.Body("consumer_id"))),
      firCount: S.optional(S.NullOr(S.Number).pipe(T.Body("fir_count"))),
      frameHeight: S.optional(S.NullOr(S.Number).pipe(T.Body("frame_height"))),
      frameWidth: S.optional(S.NullOr(S.Number).pipe(T.Body("frame_width"))),
      framesDecoded: S.optional(
        S.NullOr(S.Number).pipe(T.Body("frames_decoded")),
      ),
      framesDropped: S.optional(
        S.NullOr(S.Number).pipe(T.Body("frames_dropped")),
      ),
      framesPerSecond: S.optional(
        S.NullOr(S.Number).pipe(T.Body("frames_per_second")),
      ),
      jitter: S.optional(S.NullOr(S.Number)),
      jitterBufferDelay: S.optional(
        S.NullOr(S.Number).pipe(T.Body("jitter_buffer_delay")),
      ),
      jitterBufferEmittedCount: S.optional(
        S.NullOr(S.Number).pipe(T.Body("jitter_buffer_emitted_count")),
      ),
      keyFramesDecoded: S.optional(
        S.NullOr(S.Number).pipe(T.Body("key_frames_decoded")),
      ),
      mid: S.optional(S.NullOr(S.String)),
      mosQuality: S.optional(S.NullOr(S.Number).pipe(T.Body("mos_quality"))),
      packetsLost: S.optional(S.NullOr(S.Number).pipe(T.Body("packets_lost"))),
      packetsReceived: S.optional(
        S.NullOr(S.Number).pipe(T.Body("packets_received")),
      ),
      peerId: S.optional(S.NullOr(S.String).pipe(T.Body("peer_id"))),
      producerId: S.optional(S.NullOr(S.String).pipe(T.Body("producer_id"))),
      ssrc: S.optional(S.NullOr(S.Number)),
      timestamp: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier:
      "SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoConsumerItem",
  }) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoConsumerItem>;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoConsumerList =
  Array<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoConsumerItem>;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoConsumerList =
  /*@__PURE__*/ S.Array(
    SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoConsumerItem,
  ) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoConsumerList>;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoConsumerCumulativeFramePerSecond =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoConsumerCumulativeFramePerSecond =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoConsumerCumulativeFrameWidth =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoConsumerCumulativeFrameWidth =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos;

export interface SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoConsumerCumulativeIssues {
  lagFraction?: number | null;
  noVideoFraction?: number | null;
  poorResolutionFraction?: number | null;
}
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoConsumerCumulativeIssues =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      lagFraction: S.optional(S.NullOr(S.Number).pipe(T.Body("lag_fraction"))),
      noVideoFraction: S.optional(
        S.NullOr(S.Number).pipe(T.Body("no_video_fraction")),
      ),
      poorResolutionFraction: S.optional(
        S.NullOr(S.Number).pipe(T.Body("poor_resolution_fraction")),
      ),
    }),
  ).annotate({
    identifier:
      "SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoConsumerCumulativeIssues",
  }) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoConsumerCumulativeIssues>;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoConsumerCumulativeJitterBufferDelay =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeJitterBufferDelay;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoConsumerCumulativeJitterBufferDelay =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeJitterBufferDelay;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoConsumerCumulativePacketLoss =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativePacketLoss;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoConsumerCumulativePacketLoss =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativePacketLoss;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoConsumerCumulativeQualityMos =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoConsumerCumulativeQualityMos =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos;

export interface SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoConsumerCumulative {
  /** Distribution summary with average and percentiles. */
  framePerSecond?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos | null;
  /** Distribution summary with average and percentiles. */
  frameWidth?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos | null;
  issues?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoConsumerCumulativeIssues | null;
  /** Cumulative latency distribution (milliseconds-based thresholds). */
  jitterBufferDelay?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeJitterBufferDelay | null;
  keyFramesDecodedFraction?: number | null;
  /** Cumulative packet loss distribution. */
  packetLoss?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativePacketLoss | null;
  /** Distribution summary with average and percentiles. */
  qualityMos?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos | null;
}
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoConsumerCumulative =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      framePerSecond: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos,
        ).pipe(T.Body("frame_per_second")),
      ),
      frameWidth: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos,
        ).pipe(T.Body("frame_width")),
      ),
      issues: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoConsumerCumulativeIssues,
        ),
      ),
      jitterBufferDelay: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeJitterBufferDelay,
        ).pipe(T.Body("jitter_buffer_delay")),
      ),
      keyFramesDecodedFraction: S.optional(
        S.NullOr(S.Number).pipe(T.Body("key_frames_decoded_fraction")),
      ),
      packetLoss: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativePacketLoss,
        ).pipe(T.Body("packet_loss")),
      ),
      qualityMos: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos,
        ).pipe(T.Body("quality_mos")),
      ),
    }),
  ).annotate({
    identifier:
      "SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoConsumerCumulative",
  }) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoConsumerCumulative>;

export interface SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerItemQualityLimitationDurations {
  bandwidth?: number | null;
  cpu?: number | null;
  none?: number | null;
  other?: number | null;
}
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerItemQualityLimitationDurations =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      bandwidth: S.optional(S.NullOr(S.Number)),
      cpu: S.optional(S.NullOr(S.Number)),
      none: S.optional(S.NullOr(S.Number)),
      other: S.optional(S.NullOr(S.Number)),
    }),
  ).annotate({
    identifier:
      "SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerItemQualityLimitationDurations",
  }) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerItemQualityLimitationDurations>;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerItemQualityLimitationReason =
  | "cpu"
  | "bandwidth"
  | "none"
  | "other";
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerItemQualityLimitationReason =
  /*@__PURE__*/ S.String;

export interface SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerItem {
  bytesSent?: number | null;
  firCount?: number | null;
  frameHeight?: number | null;
  frameWidth?: number | null;
  framesEncoded?: number | null;
  framesPerSecond?: number | null;
  jitter?: number | null;
  keyFramesEncoded?: number | null;
  mid?: string | null;
  mosQuality?: number | null;
  packetsLost?: number | null;
  packetsSent?: number | null;
  pliCount?: number | null;
  producerId?: string | null;
  qualityLimitationDurations?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerItemQualityLimitationDurations | null;
  qualityLimitationReason?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerItemQualityLimitationReason | null;
  qualityLimitationResolutionChanges?: number | null;
  rtt?: number | null;
  ssrc?: number | null;
  timestamp?: string | null;
}
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      bytesSent: S.optional(S.NullOr(S.Number).pipe(T.Body("bytes_sent"))),
      firCount: S.optional(S.NullOr(S.Number).pipe(T.Body("fir_count"))),
      frameHeight: S.optional(S.NullOr(S.Number).pipe(T.Body("frame_height"))),
      frameWidth: S.optional(S.NullOr(S.Number).pipe(T.Body("frame_width"))),
      framesEncoded: S.optional(
        S.NullOr(S.Number).pipe(T.Body("frames_encoded")),
      ),
      framesPerSecond: S.optional(
        S.NullOr(S.Number).pipe(T.Body("frames_per_second")),
      ),
      jitter: S.optional(S.NullOr(S.Number)),
      keyFramesEncoded: S.optional(
        S.NullOr(S.Number).pipe(T.Body("key_frames_encoded")),
      ),
      mid: S.optional(S.NullOr(S.String)),
      mosQuality: S.optional(S.NullOr(S.Number).pipe(T.Body("mos_quality"))),
      packetsLost: S.optional(S.NullOr(S.Number).pipe(T.Body("packets_lost"))),
      packetsSent: S.optional(S.NullOr(S.Number).pipe(T.Body("packets_sent"))),
      pliCount: S.optional(S.NullOr(S.Number).pipe(T.Body("pli_count"))),
      producerId: S.optional(S.NullOr(S.String).pipe(T.Body("producer_id"))),
      qualityLimitationDurations: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerItemQualityLimitationDurations,
        ).pipe(T.Body("quality_limitation_durations")),
      ),
      qualityLimitationReason: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerItemQualityLimitationReason,
        ).pipe(T.Body("quality_limitation_reason")),
      ),
      qualityLimitationResolutionChanges: S.optional(
        S.NullOr(S.Number).pipe(
          T.Body("quality_limitation_resolution_changes"),
        ),
      ),
      rtt: S.optional(S.NullOr(S.Number)),
      ssrc: S.optional(S.NullOr(S.Number)),
      timestamp: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier:
      "SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerItem",
  }) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerItem>;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerList =
  Array<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerItem>;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerList =
  /*@__PURE__*/ S.Array(
    SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerItem,
  ) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerList>;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerCumulativeFramePerSecond =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerCumulativeFramePerSecond =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerCumulativeFrameWidth =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerCumulativeFrameWidth =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos;

export interface SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerCumulativeIssues {
  bandwidthQualityLimitationFraction?: number | null;
  cpuQualityLimitationFraction?: number | null;
  noVideoFraction?: number | null;
  poorResolutionFraction?: number | null;
  qualityLimitationFraction?: number | null;
}
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerCumulativeIssues =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      bandwidthQualityLimitationFraction: S.optional(
        S.NullOr(S.Number).pipe(
          T.Body("bandwidth_quality_limitation_fraction"),
        ),
      ),
      cpuQualityLimitationFraction: S.optional(
        S.NullOr(S.Number).pipe(T.Body("cpu_quality_limitation_fraction")),
      ),
      noVideoFraction: S.optional(
        S.NullOr(S.Number).pipe(T.Body("no_video_fraction")),
      ),
      poorResolutionFraction: S.optional(
        S.NullOr(S.Number).pipe(T.Body("poor_resolution_fraction")),
      ),
      qualityLimitationFraction: S.optional(
        S.NullOr(S.Number).pipe(T.Body("quality_limitation_fraction")),
      ),
    }),
  ).annotate({
    identifier:
      "SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerCumulativeIssues",
  }) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerCumulativeIssues>;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerCumulativePacketLoss =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativePacketLoss;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerCumulativePacketLoss =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativePacketLoss;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerCumulativeQualityMos =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerCumulativeQualityMos =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerCumulativeRtt =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeJitterBufferDelay;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerCumulativeRtt =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeJitterBufferDelay;

export interface SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerCumulative {
  /** Distribution summary with average and percentiles. */
  framePerSecond?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos | null;
  /** Distribution summary with average and percentiles. */
  frameWidth?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos | null;
  highNegativeFeedbackFraction?: number | null;
  issues?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerCumulativeIssues | null;
  keyFramesEncodedFraction?: number | null;
  /** Cumulative packet loss distribution. */
  packetLoss?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativePacketLoss | null;
  /** Distribution summary with average and percentiles. */
  qualityMos?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos | null;
  /** Cumulative latency distribution (milliseconds-based thresholds). */
  rtt?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeJitterBufferDelay | null;
}
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerCumulative =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      framePerSecond: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos,
        ).pipe(T.Body("frame_per_second")),
      ),
      frameWidth: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos,
        ).pipe(T.Body("frame_width")),
      ),
      highNegativeFeedbackFraction: S.optional(
        S.NullOr(S.Number).pipe(T.Body("high_negative_feedback_fraction")),
      ),
      issues: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerCumulativeIssues,
        ),
      ),
      keyFramesEncodedFraction: S.optional(
        S.NullOr(S.Number).pipe(T.Body("key_frames_encoded_fraction")),
      ),
      packetLoss: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativePacketLoss,
        ).pipe(T.Body("packet_loss")),
      ),
      qualityMos: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos,
        ).pipe(T.Body("quality_mos")),
      ),
      rtt: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeJitterBufferDelay,
        ),
      ),
    }),
  ).annotate({
    identifier:
      "SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerCumulative",
  }) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerCumulative>;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoConsumerItem =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoConsumerItem;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoConsumerItem =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoConsumerItem;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoConsumerList =
  Array<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoConsumerItem>;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoConsumerList =
  /*@__PURE__*/ S.Array(
    SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoConsumerItem,
  ) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoConsumerList>;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoConsumerCumulativeFramePerSecond =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoConsumerCumulativeFramePerSecond =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoConsumerCumulativeFrameWidth =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoConsumerCumulativeFrameWidth =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoConsumerCumulativeIssues =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoConsumerCumulativeIssues;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoConsumerCumulativeIssues =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoConsumerCumulativeIssues;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoConsumerCumulativeJitterBufferDelay =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeJitterBufferDelay;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoConsumerCumulativeJitterBufferDelay =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeJitterBufferDelay;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoConsumerCumulativePacketLoss =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativePacketLoss;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoConsumerCumulativePacketLoss =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativePacketLoss;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoConsumerCumulativeQualityMos =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoConsumerCumulativeQualityMos =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoConsumerCumulative =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoConsumerCumulative;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoConsumerCumulative =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoConsumerCumulative;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoProducerItemQualityLimitationDurations =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerItemQualityLimitationDurations;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoProducerItemQualityLimitationDurations =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerItemQualityLimitationDurations;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoProducerItemQualityLimitationReason =
  | "cpu"
  | "bandwidth"
  | "none"
  | "other";
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoProducerItemQualityLimitationReason =
  /*@__PURE__*/ S.String;

export interface SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoProducerItem {
  bytesSent?: number | null;
  firCount?: number | null;
  frameHeight?: number | null;
  frameWidth?: number | null;
  framesEncoded?: number | null;
  framesPerSecond?: number | null;
  jitter?: number | null;
  keyFramesEncoded?: number | null;
  mid?: string | null;
  mosQuality?: number | null;
  packetsLost?: number | null;
  packetsSent?: number | null;
  pliCount?: number | null;
  producerId?: string | null;
  qualityLimitationDurations?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerItemQualityLimitationDurations | null;
  qualityLimitationReason?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoProducerItemQualityLimitationReason | null;
  qualityLimitationResolutionChanges?: number | null;
  rtt?: number | null;
  ssrc?: number | null;
  timestamp?: string | null;
}
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoProducerItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      bytesSent: S.optional(S.NullOr(S.Number).pipe(T.Body("bytes_sent"))),
      firCount: S.optional(S.NullOr(S.Number).pipe(T.Body("fir_count"))),
      frameHeight: S.optional(S.NullOr(S.Number).pipe(T.Body("frame_height"))),
      frameWidth: S.optional(S.NullOr(S.Number).pipe(T.Body("frame_width"))),
      framesEncoded: S.optional(
        S.NullOr(S.Number).pipe(T.Body("frames_encoded")),
      ),
      framesPerSecond: S.optional(
        S.NullOr(S.Number).pipe(T.Body("frames_per_second")),
      ),
      jitter: S.optional(S.NullOr(S.Number)),
      keyFramesEncoded: S.optional(
        S.NullOr(S.Number).pipe(T.Body("key_frames_encoded")),
      ),
      mid: S.optional(S.NullOr(S.String)),
      mosQuality: S.optional(S.NullOr(S.Number).pipe(T.Body("mos_quality"))),
      packetsLost: S.optional(S.NullOr(S.Number).pipe(T.Body("packets_lost"))),
      packetsSent: S.optional(S.NullOr(S.Number).pipe(T.Body("packets_sent"))),
      pliCount: S.optional(S.NullOr(S.Number).pipe(T.Body("pli_count"))),
      producerId: S.optional(S.NullOr(S.String).pipe(T.Body("producer_id"))),
      qualityLimitationDurations: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerItemQualityLimitationDurations,
        ).pipe(T.Body("quality_limitation_durations")),
      ),
      qualityLimitationReason: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoProducerItemQualityLimitationReason,
        ).pipe(T.Body("quality_limitation_reason")),
      ),
      qualityLimitationResolutionChanges: S.optional(
        S.NullOr(S.Number).pipe(
          T.Body("quality_limitation_resolution_changes"),
        ),
      ),
      rtt: S.optional(S.NullOr(S.Number)),
      ssrc: S.optional(S.NullOr(S.Number)),
      timestamp: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier:
      "SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoProducerItem",
  }) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoProducerItem>;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoProducerList =
  Array<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoProducerItem>;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoProducerList =
  /*@__PURE__*/ S.Array(
    SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoProducerItem,
  ) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoProducerList>;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoProducerCumulativeFramePerSecond =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoProducerCumulativeFramePerSecond =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoProducerCumulativeFrameWidth =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoProducerCumulativeFrameWidth =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoProducerCumulativeIssues =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerCumulativeIssues;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoProducerCumulativeIssues =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerCumulativeIssues;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoProducerCumulativePacketLoss =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativePacketLoss;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoProducerCumulativePacketLoss =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativePacketLoss;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoProducerCumulativeQualityMos =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoProducerCumulativeQualityMos =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeQualityMos;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoProducerCumulativeRtt =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeJitterBufferDelay;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoProducerCumulativeRtt =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulativeJitterBufferDelay;

export type SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoProducerCumulative =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerCumulative;
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoProducerCumulative =
  SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerCumulative;

export interface SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQuality {
  audioConsumer?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerList | null;
  /** Aggregated inbound (consumer) audio statistics for the session. */
  audioConsumerCumulative?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulative | null;
  audioProducer?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioProducerList | null;
  /** Aggregated outbound (producer) audio statistics for the session. */
  audioProducerCumulative?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioProducerCumulative | null;
  screenshareAudioConsumer?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareAudioConsumerList | null;
  /** Aggregated inbound (consumer) audio statistics for the session. */
  screenshareAudioConsumerCumulative?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulative | null;
  screenshareAudioProducer?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareAudioProducerList | null;
  /** Aggregated outbound (producer) audio statistics for the session. */
  screenshareAudioProducerCumulative?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioProducerCumulative | null;
  screenshareVideoConsumer?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoConsumerList | null;
  /** Aggregated inbound (consumer) video statistics for the session. */
  screenshareVideoConsumerCumulative?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoConsumerCumulative | null;
  screenshareVideoProducer?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerList | null;
  /** Aggregated outbound (producer) video statistics for the session. */
  screenshareVideoProducerCumulative?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerCumulative | null;
  videoConsumer?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoConsumerList | null;
  /** Aggregated inbound (consumer) video statistics for the session. */
  videoConsumerCumulative?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoConsumerCumulative | null;
  videoProducer?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoProducerList | null;
  /** Aggregated outbound (producer) video statistics for the session. */
  videoProducerCumulative?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerCumulative | null;
}
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQuality =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      audioConsumer: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerList,
        ).pipe(T.Body("audio_consumer")),
      ),
      audioConsumerCumulative: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulative,
        ).pipe(T.Body("audio_consumer_cumulative")),
      ),
      audioProducer: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioProducerList,
        ).pipe(T.Body("audio_producer")),
      ),
      audioProducerCumulative: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioProducerCumulative,
        ).pipe(T.Body("audio_producer_cumulative")),
      ),
      screenshareAudioConsumer: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareAudioConsumerList,
        ).pipe(T.Body("screenshare_audio_consumer")),
      ),
      screenshareAudioConsumerCumulative: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioConsumerCumulative,
        ).pipe(T.Body("screenshare_audio_consumer_cumulative")),
      ),
      screenshareAudioProducer: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareAudioProducerList,
        ).pipe(T.Body("screenshare_audio_producer")),
      ),
      screenshareAudioProducerCumulative: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityAudioProducerCumulative,
        ).pipe(T.Body("screenshare_audio_producer_cumulative")),
      ),
      screenshareVideoConsumer: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoConsumerList,
        ).pipe(T.Body("screenshare_video_consumer")),
      ),
      screenshareVideoConsumerCumulative: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoConsumerCumulative,
        ).pipe(T.Body("screenshare_video_consumer_cumulative")),
      ),
      screenshareVideoProducer: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerList,
        ).pipe(T.Body("screenshare_video_producer")),
      ),
      screenshareVideoProducerCumulative: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerCumulative,
        ).pipe(T.Body("screenshare_video_producer_cumulative")),
      ),
      videoConsumer: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoConsumerList,
        ).pipe(T.Body("video_consumer")),
      ),
      videoConsumerCumulative: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoConsumerCumulative,
        ).pipe(T.Body("video_consumer_cumulative")),
      ),
      videoProducer: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityVideoProducerList,
        ).pipe(T.Body("video_producer")),
      ),
      videoProducerCumulative: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQualityScreenshareVideoProducerCumulative,
        ).pipe(T.Body("video_producer_cumulative")),
      ),
    }),
  ).annotate({
    identifier:
      "SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQuality",
  }) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQuality>;

export interface SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReport {
  /** Connection and device metadata for the participant. */
  metadata?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadata | null;
  /** Media quality statistics for the participant. */
  quality?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQuality | null;
}
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReport =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      metadata: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportMetadata,
        ),
      ),
      quality: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReportQuality,
        ),
      ),
    }),
  ).annotate({
    identifier:
      "SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReport",
  }) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReport>;

export interface SessionsGetParticipantDataFromPeerIdResponseDataParticipant {
  /** ID of the participant. */
  id?: string | null;
  /** timestamp when this participant was created. */
  createdAt?: string | null;
  /** ID passed by client to create this participant. */
  customParticipantId?: string | null;
  /** Display name of participant when joining the session. */
  displayName?: string | null;
  /** number of minutes for which the participant was in the session. */
  duration?: number | null;
  /** timestamp at which participant joined the session. */
  joinedAt?: string | null;
  /** timestamp at which participant left the session. */
  leftAt?: string | null;
  /** Connection lifecycle events for the participant's peer. */
  peerEvents?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerEventsList | null;
  /** Peer call statistics report. */
  peerReport?: SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReport | null;
  /** Name of the preset associated with the participant. */
  role?: string | null;
  sessionId?: string | null;
  /** timestamp when this participant's data was last updated. */
  updatedAt?: string | null;
  /** User id for this participant. */
  userId?: string | null;
}
export const SessionsGetParticipantDataFromPeerIdResponseDataParticipant =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.optional(S.NullOr(S.String)),
      createdAt: S.optional(S.NullOr(S.String).pipe(T.Body("created_at"))),
      customParticipantId: S.optional(
        S.NullOr(S.String).pipe(T.Body("custom_participant_id")),
      ),
      displayName: S.optional(S.NullOr(S.String).pipe(T.Body("display_name"))),
      duration: S.optional(S.NullOr(S.Number)),
      joinedAt: S.optional(S.NullOr(S.String).pipe(T.Body("joined_at"))),
      leftAt: S.optional(S.NullOr(S.String).pipe(T.Body("left_at"))),
      peerEvents: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerEventsList,
        ).pipe(T.Body("peer_events")),
      ),
      peerReport: S.optional(
        S.NullOr(
          SessionsGetParticipantDataFromPeerIdResponseDataParticipantPeerReport,
        ).pipe(T.Body("peer_report")),
      ),
      role: S.optional(S.NullOr(S.String)),
      sessionId: S.optional(S.NullOr(S.String).pipe(T.Body("session_id"))),
      updatedAt: S.optional(S.NullOr(S.String).pipe(T.Body("updated_at"))),
      userId: S.optional(S.NullOr(S.String).pipe(T.Body("user_id"))),
    }),
  ).annotate({
    identifier: "SessionsGetParticipantDataFromPeerIdResponseDataParticipant",
  }) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseDataParticipant>;

export interface SessionsGetParticipantDataFromPeerIdResponseData {
  participant?: SessionsGetParticipantDataFromPeerIdResponseDataParticipant | null;
}
export const SessionsGetParticipantDataFromPeerIdResponseData =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      participant: S.optional(
        S.NullOr(SessionsGetParticipantDataFromPeerIdResponseDataParticipant),
      ),
    }),
  ).annotate({
    identifier: "SessionsGetParticipantDataFromPeerIdResponseData",
  }) as any as S.Schema<SessionsGetParticipantDataFromPeerIdResponseData>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface GetParticipantDataFromPeerIdSessionResponse {
  data?: SessionsGetParticipantDataFromPeerIdResponseData | null;
}
export const GetParticipantDataFromPeerIdSessionResponse =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      data: S.optional(
        S.NullOr(SessionsGetParticipantDataFromPeerIdResponseData),
      ),
    }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
  ).annotate({
    identifier: "GetParticipantDataFromPeerIdSessionResponse",
  }) as any as S.Schema<GetParticipantDataFromPeerIdSessionResponse>;

export interface GetPresetRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  /** The page number from which you want your page search results to be displayed. */
  pageNo?: number;
  /** Number of results per page */
  perPage?: number;
  /** Search presets by name. */
  search?: string;
}
export const GetPresetRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    appId: S.String.pipe(T.Label("app_id")),
    pageNo: S.optional(S.Number.pipe(T.Query("page_no"))),
    perPage: S.optional(S.Number.pipe(T.Query("per_page"))),
    search: S.optional(S.String.pipe(T.Query())),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/realtime/kit/{app_id}/presets",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetPresetRequest",
}) as any as S.Schema<GetPresetRequest>;

export interface PresetsGetResponseDataItem {
  /** ID of the preset */
  id?: string | null;
  /** Timestamp this preset was created at */
  createdAt?: string | null;
  /** Name of the preset */
  name?: string | null;
  /** Timestamp this preset was last updated */
  updatedAt?: string | null;
}
export const PresetsGetResponseDataItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.String)),
    createdAt: S.optional(S.NullOr(S.String).pipe(T.Body("created_at"))),
    name: S.optional(S.NullOr(S.String)),
    updatedAt: S.optional(S.NullOr(S.String).pipe(T.Body("updated_at"))),
  }),
).annotate({
  identifier: "PresetsGetResponseDataItem",
}) as any as S.Schema<PresetsGetResponseDataItem>;

export type PresetsGetResponseDataList = Array<PresetsGetResponseDataItem>;
export const PresetsGetResponseDataList = /*@__PURE__*/ S.Array(
  PresetsGetResponseDataItem,
) as any as S.Schema<PresetsGetResponseDataList>;

export type PresetsGetResponsePaging = MeetingsGetResponsePaging;
export const PresetsGetResponsePaging = MeetingsGetResponsePaging;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface GetPresetResponse {
  data: PresetsGetResponseDataList;
  paging: MeetingsGetResponsePaging;
}
export const GetPresetResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    data: PresetsGetResponseDataList,
    paging: MeetingsGetResponsePaging,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetPresetResponse",
}) as any as S.Schema<GetPresetResponse>;

export interface GetPresetByIdPresetRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  presetId: string;
}
export const GetPresetByIdPresetRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    appId: S.String.pipe(T.Label("app_id")),
    presetId: S.String.pipe(T.Label("preset_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/realtime/kit/{app_id}/presets/{preset_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetPresetByIdPresetRequest",
}) as any as S.Schema<GetPresetByIdPresetRequest>;

export type PresetsGetPresetByIdResponseDataConfigMaxVideoStreams =
  PresetsCreateRequestConfigMaxVideoStreams;
export const PresetsGetPresetByIdResponseDataConfigMaxVideoStreams =
  PresetsCreateRequestConfigMaxVideoStreams;

export type PresetsGetPresetByIdResponseDataConfigMediaScreenshareQuality =
  | "hd"
  | "vga"
  | "qvga"
  | "fhd"
  | "uhd";
export const PresetsGetPresetByIdResponseDataConfigMediaScreenshareQuality =
  /*@__PURE__*/ S.String;

export interface PresetsGetPresetByIdResponseDataConfigMediaScreenshare {
  /** Frame rate of screen share */
  frameRate: number;
  /** Quality of screen share */
  quality: PresetsGetPresetByIdResponseDataConfigMediaScreenshareQuality;
}
export const PresetsGetPresetByIdResponseDataConfigMediaScreenshare =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      frameRate: S.Number.pipe(T.Body("frame_rate")),
      quality: PresetsGetPresetByIdResponseDataConfigMediaScreenshareQuality,
    }),
  ).annotate({
    identifier: "PresetsGetPresetByIdResponseDataConfigMediaScreenshare",
  }) as any as S.Schema<PresetsGetPresetByIdResponseDataConfigMediaScreenshare>;

export type PresetsGetPresetByIdResponseDataConfigMediaVideoQuality =
  | "hd"
  | "vga"
  | "qvga"
  | "fhd"
  | "uhd";
export const PresetsGetPresetByIdResponseDataConfigMediaVideoQuality =
  /*@__PURE__*/ S.String;

export interface PresetsGetPresetByIdResponseDataConfigMediaVideo {
  /** Frame rate of participants' video */
  frameRate: number;
  /** Video quality of participants */
  quality: PresetsGetPresetByIdResponseDataConfigMediaVideoQuality;
  /** Enable simulcast for participant videos. */
  simulcast?: boolean | null;
}
export const PresetsGetPresetByIdResponseDataConfigMediaVideo =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      frameRate: S.Number.pipe(T.Body("frame_rate")),
      quality: PresetsGetPresetByIdResponseDataConfigMediaVideoQuality,
      simulcast: S.optional(S.NullOr(S.Boolean)),
    }),
  ).annotate({
    identifier: "PresetsGetPresetByIdResponseDataConfigMediaVideo",
  }) as any as S.Schema<PresetsGetPresetByIdResponseDataConfigMediaVideo>;

export type PresetsGetPresetByIdResponseDataConfigMediaAudio =
  PresetsCreateResponseDataConfigMediaAudio;
export const PresetsGetPresetByIdResponseDataConfigMediaAudio =
  PresetsCreateResponseDataConfigMediaAudio;

export interface PresetsGetPresetByIdResponseDataConfigMedia {
  /** Configuration options for participant screen shares */
  screenshare: PresetsGetPresetByIdResponseDataConfigMediaScreenshare;
  /** Configuration options for participant videos */
  video: PresetsGetPresetByIdResponseDataConfigMediaVideo;
  /** Control options for Audio quality. */
  audio?: PresetsCreateResponseDataConfigMediaAudio | null;
}
export const PresetsGetPresetByIdResponseDataConfigMedia =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      screenshare: PresetsGetPresetByIdResponseDataConfigMediaScreenshare,
      video: PresetsGetPresetByIdResponseDataConfigMediaVideo,
      audio: S.optional(S.NullOr(PresetsCreateResponseDataConfigMediaAudio)),
    }),
  ).annotate({
    identifier: "PresetsGetPresetByIdResponseDataConfigMedia",
  }) as any as S.Schema<PresetsGetPresetByIdResponseDataConfigMedia>;

export type PresetsGetPresetByIdResponseDataConfigViewType =
  | "GROUP_CALL"
  | "WEBINAR"
  | "AUDIO_ROOM"
  | "LIVESTREAM";
export const PresetsGetPresetByIdResponseDataConfigViewType =
  /*@__PURE__*/ S.String;

export type PresetsGetPresetByIdResponseDataConfigLivestreamViewerQualitiesList =
  Array<number>;
export const PresetsGetPresetByIdResponseDataConfigLivestreamViewerQualitiesList =
  /*@__PURE__*/ S.Array(
    S.Number,
  ) as any as S.Schema<PresetsGetPresetByIdResponseDataConfigLivestreamViewerQualitiesList>;

export interface PresetsGetPresetByIdResponseDataConfig {
  /** Maximum number of screen shares that can be active at a given time */
  maxScreenshareCount: number;
  /** Maximum number of streams that are visible on a device */
  maxVideoStreams: PresetsCreateRequestConfigMaxVideoStreams;
  /** Media configuration options. eg: Video quality */
  media: PresetsGetPresetByIdResponseDataConfigMedia;
  /** Type of the meeting */
  viewType: PresetsGetPresetByIdResponseDataConfigViewType;
  /** Livestream viewer quality levels. */
  livestreamViewerQualities?: PresetsGetPresetByIdResponseDataConfigLivestreamViewerQualitiesList | null;
}
export const PresetsGetPresetByIdResponseDataConfig = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      maxScreenshareCount: S.Number.pipe(T.Body("max_screenshare_count")),
      maxVideoStreams: PresetsCreateRequestConfigMaxVideoStreams.pipe(
        T.Body("max_video_streams"),
      ),
      media: PresetsGetPresetByIdResponseDataConfigMedia,
      viewType: PresetsGetPresetByIdResponseDataConfigViewType.pipe(
        T.Body("view_type"),
      ),
      livestreamViewerQualities: S.optional(
        S.NullOr(
          PresetsGetPresetByIdResponseDataConfigLivestreamViewerQualitiesList,
        ).pipe(T.Body("livestream_viewer_qualities")),
      ),
    }),
).annotate({
  identifier: "PresetsGetPresetByIdResponseDataConfig",
}) as any as S.Schema<PresetsGetPresetByIdResponseDataConfig>;

export type PresetsGetPresetByIdResponseDataPermissionsChatPrivate =
  PresetsCreateRequestPermissionsChatPrivate;
export const PresetsGetPresetByIdResponseDataPermissionsChatPrivate =
  PresetsCreateRequestPermissionsChatPrivate;

export type PresetsGetPresetByIdResponseDataPermissionsChatPublic =
  PresetsCreateRequestPermissionsChatPublic;
export const PresetsGetPresetByIdResponseDataPermissionsChatPublic =
  PresetsCreateRequestPermissionsChatPublic;

export type PresetsGetPresetByIdResponseDataPermissionsChat =
  PresetsCreateRequestPermissionsChat;
export const PresetsGetPresetByIdResponseDataPermissionsChat =
  PresetsCreateRequestPermissionsChat;

export type PresetsGetPresetByIdResponseDataPermissionsConnectedMeetings =
  PresetsCreateRequestPermissionsConnectedMeetings;
export const PresetsGetPresetByIdResponseDataPermissionsConnectedMeetings =
  PresetsCreateRequestPermissionsConnectedMeetings;

export type PresetsGetPresetByIdResponseDataPermissionsMediaAudioCanProduce =
  | "ALLOWED"
  | "NOT_ALLOWED"
  | "CAN_REQUEST";
export const PresetsGetPresetByIdResponseDataPermissionsMediaAudioCanProduce =
  /*@__PURE__*/ S.String;

export interface PresetsGetPresetByIdResponseDataPermissionsMediaAudio {
  /** Can produce audio */
  canProduce: PresetsGetPresetByIdResponseDataPermissionsMediaAudioCanProduce;
}
export const PresetsGetPresetByIdResponseDataPermissionsMediaAudio =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      canProduce:
        PresetsGetPresetByIdResponseDataPermissionsMediaAudioCanProduce.pipe(
          T.Body("can_produce"),
        ),
    }),
  ).annotate({
    identifier: "PresetsGetPresetByIdResponseDataPermissionsMediaAudio",
  }) as any as S.Schema<PresetsGetPresetByIdResponseDataPermissionsMediaAudio>;

export type PresetsGetPresetByIdResponseDataPermissionsMediaScreenshareCanProduce =
  | "ALLOWED"
  | "NOT_ALLOWED"
  | "CAN_REQUEST";
export const PresetsGetPresetByIdResponseDataPermissionsMediaScreenshareCanProduce =
  /*@__PURE__*/ S.String;

export interface PresetsGetPresetByIdResponseDataPermissionsMediaScreenshare {
  /** Can produce screen share video */
  canProduce: PresetsGetPresetByIdResponseDataPermissionsMediaScreenshareCanProduce;
}
export const PresetsGetPresetByIdResponseDataPermissionsMediaScreenshare =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      canProduce:
        PresetsGetPresetByIdResponseDataPermissionsMediaScreenshareCanProduce.pipe(
          T.Body("can_produce"),
        ),
    }),
  ).annotate({
    identifier: "PresetsGetPresetByIdResponseDataPermissionsMediaScreenshare",
  }) as any as S.Schema<PresetsGetPresetByIdResponseDataPermissionsMediaScreenshare>;

export type PresetsGetPresetByIdResponseDataPermissionsMediaVideoCanProduce =
  | "ALLOWED"
  | "NOT_ALLOWED"
  | "CAN_REQUEST";
export const PresetsGetPresetByIdResponseDataPermissionsMediaVideoCanProduce =
  /*@__PURE__*/ S.String;

export interface PresetsGetPresetByIdResponseDataPermissionsMediaVideo {
  /** Can produce video */
  canProduce: PresetsGetPresetByIdResponseDataPermissionsMediaVideoCanProduce;
}
export const PresetsGetPresetByIdResponseDataPermissionsMediaVideo =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      canProduce:
        PresetsGetPresetByIdResponseDataPermissionsMediaVideoCanProduce.pipe(
          T.Body("can_produce"),
        ),
    }),
  ).annotate({
    identifier: "PresetsGetPresetByIdResponseDataPermissionsMediaVideo",
  }) as any as S.Schema<PresetsGetPresetByIdResponseDataPermissionsMediaVideo>;

export interface PresetsGetPresetByIdResponseDataPermissionsMedia {
  /** Audio permissions */
  audio: PresetsGetPresetByIdResponseDataPermissionsMediaAudio;
  /** Screenshare permissions */
  screenshare: PresetsGetPresetByIdResponseDataPermissionsMediaScreenshare;
  /** Video permissions */
  video: PresetsGetPresetByIdResponseDataPermissionsMediaVideo;
}
export const PresetsGetPresetByIdResponseDataPermissionsMedia =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      audio: PresetsGetPresetByIdResponseDataPermissionsMediaAudio,
      screenshare: PresetsGetPresetByIdResponseDataPermissionsMediaScreenshare,
      video: PresetsGetPresetByIdResponseDataPermissionsMediaVideo,
    }),
  ).annotate({
    identifier: "PresetsGetPresetByIdResponseDataPermissionsMedia",
  }) as any as S.Schema<PresetsGetPresetByIdResponseDataPermissionsMedia>;

export type PresetsGetPresetByIdResponseDataPermissionsPlugins =
  PresetsCreateRequestPermissionsPlugins;
export const PresetsGetPresetByIdResponseDataPermissionsPlugins =
  PresetsCreateRequestPermissionsPlugins;

export type PresetsGetPresetByIdResponseDataPermissionsPolls =
  PresetsCreateRequestPermissionsPolls;
export const PresetsGetPresetByIdResponseDataPermissionsPolls =
  PresetsCreateRequestPermissionsPolls;

export type PresetsGetPresetByIdResponseDataPermissionsRecorderType =
  | "RECORDER"
  | "LIVESTREAMER"
  | "NONE";
export const PresetsGetPresetByIdResponseDataPermissionsRecorderType =
  /*@__PURE__*/ S.String;

export type PresetsGetPresetByIdResponseDataPermissionsWaitingRoomType =
  | "SKIP"
  | "ON_PRIVILEGED_USER_ENTRY"
  | "SKIP_ON_ACCEPT";
export const PresetsGetPresetByIdResponseDataPermissionsWaitingRoomType =
  /*@__PURE__*/ S.String;

export type PresetsGetPresetByIdResponseDataPermissionsStageAccess =
  | "ALLOWED"
  | "NOT_ALLOWED"
  | "CAN_REQUEST";
export const PresetsGetPresetByIdResponseDataPermissionsStageAccess =
  /*@__PURE__*/ S.String;

export interface PresetsGetPresetByIdResponseDataPermissions {
  /** Whether this participant can accept waiting requests */
  acceptWaitingRequests: boolean;
  canAcceptProductionRequests: boolean;
  canChangeParticipantPermissions: boolean;
  canEditDisplayName: boolean;
  canLivestream: boolean;
  canRecord: boolean;
  canSpotlight: boolean;
  chat: PresetsCreateRequestPermissionsChat;
  connectedMeetings: PresetsCreateRequestPermissionsConnectedMeetings;
  disableParticipantAudio: boolean;
  disableParticipantScreensharing: boolean;
  disableParticipantVideo: boolean;
  /** Whether this participant is visible to others or not */
  hiddenParticipant: boolean;
  kickParticipant: boolean;
  /** Media permissions */
  media: PresetsGetPresetByIdResponseDataPermissionsMedia;
  pinParticipant: boolean;
  /** Plugin permissions */
  plugins: PresetsCreateRequestPermissionsPlugins;
  /** Poll permissions */
  polls: PresetsCreateRequestPermissionsPolls;
  /** Type of the recording peer */
  recorderType: PresetsGetPresetByIdResponseDataPermissionsRecorderType;
  showParticipantList: boolean;
  /** Waiting room type */
  waitingRoomType: PresetsGetPresetByIdResponseDataPermissionsWaitingRoomType;
  acceptStageRequests?: boolean | null;
  isRecorder?: boolean | null;
  stageAccess?: PresetsGetPresetByIdResponseDataPermissionsStageAccess | null;
  stageEnabled?: boolean | null;
  transcriptionEnabled?: boolean | null;
}
export const PresetsGetPresetByIdResponseDataPermissions =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      acceptWaitingRequests: S.Boolean.pipe(T.Body("accept_waiting_requests")),
      canAcceptProductionRequests: S.Boolean.pipe(
        T.Body("can_accept_production_requests"),
      ),
      canChangeParticipantPermissions: S.Boolean.pipe(
        T.Body("can_change_participant_permissions"),
      ),
      canEditDisplayName: S.Boolean.pipe(T.Body("can_edit_display_name")),
      canLivestream: S.Boolean.pipe(T.Body("can_livestream")),
      canRecord: S.Boolean.pipe(T.Body("can_record")),
      canSpotlight: S.Boolean.pipe(T.Body("can_spotlight")),
      chat: PresetsCreateRequestPermissionsChat,
      connectedMeetings: PresetsCreateRequestPermissionsConnectedMeetings.pipe(
        T.Body("connected_meetings"),
      ),
      disableParticipantAudio: S.Boolean.pipe(
        T.Body("disable_participant_audio"),
      ),
      disableParticipantScreensharing: S.Boolean.pipe(
        T.Body("disable_participant_screensharing"),
      ),
      disableParticipantVideo: S.Boolean.pipe(
        T.Body("disable_participant_video"),
      ),
      hiddenParticipant: S.Boolean.pipe(T.Body("hidden_participant")),
      kickParticipant: S.Boolean.pipe(T.Body("kick_participant")),
      media: PresetsGetPresetByIdResponseDataPermissionsMedia,
      pinParticipant: S.Boolean.pipe(T.Body("pin_participant")),
      plugins: PresetsCreateRequestPermissionsPlugins,
      polls: PresetsCreateRequestPermissionsPolls,
      recorderType:
        PresetsGetPresetByIdResponseDataPermissionsRecorderType.pipe(
          T.Body("recorder_type"),
        ),
      showParticipantList: S.Boolean.pipe(T.Body("show_participant_list")),
      waitingRoomType:
        PresetsGetPresetByIdResponseDataPermissionsWaitingRoomType.pipe(
          T.Body("waiting_room_type"),
        ),
      acceptStageRequests: S.optional(
        S.NullOr(S.Boolean).pipe(T.Body("accept_stage_requests")),
      ),
      isRecorder: S.optional(S.NullOr(S.Boolean).pipe(T.Body("is_recorder"))),
      stageAccess: S.optional(
        S.NullOr(PresetsGetPresetByIdResponseDataPermissionsStageAccess).pipe(
          T.Body("stage_access"),
        ),
      ),
      stageEnabled: S.optional(
        S.NullOr(S.Boolean).pipe(T.Body("stage_enabled")),
      ),
      transcriptionEnabled: S.optional(
        S.NullOr(S.Boolean).pipe(T.Body("transcription_enabled")),
      ),
    }),
  ).annotate({
    identifier: "PresetsGetPresetByIdResponseDataPermissions",
  }) as any as S.Schema<PresetsGetPresetByIdResponseDataPermissions>;

export type PresetsGetPresetByIdResponseDataUiDesignTokensBorderRadius =
  | "sharp"
  | "rounded"
  | "extra-rounded"
  | "circular";
export const PresetsGetPresetByIdResponseDataUiDesignTokensBorderRadius =
  /*@__PURE__*/ S.String;

export type PresetsGetPresetByIdResponseDataUiDesignTokensBorderWidth =
  | "none"
  | "thin"
  | "fat";
export const PresetsGetPresetByIdResponseDataUiDesignTokensBorderWidth =
  /*@__PURE__*/ S.String;

export type PresetsGetPresetByIdResponseDataUiDesignTokensColorsBackground =
  PresetsCreateRequestUiDesignTokensColorsBackground;
export const PresetsGetPresetByIdResponseDataUiDesignTokensColorsBackground =
  PresetsCreateRequestUiDesignTokensColorsBackground;

export type PresetsGetPresetByIdResponseDataUiDesignTokensColorsBrand =
  PresetsCreateRequestUiDesignTokensColorsBrand;
export const PresetsGetPresetByIdResponseDataUiDesignTokensColorsBrand =
  PresetsCreateRequestUiDesignTokensColorsBrand;

export type PresetsGetPresetByIdResponseDataUiDesignTokensColors =
  PresetsCreateRequestUiDesignTokensColors;
export const PresetsGetPresetByIdResponseDataUiDesignTokensColors =
  PresetsCreateRequestUiDesignTokensColors;

export type PresetsGetPresetByIdResponseDataUiDesignTokensTheme =
  | "darkest"
  | "dark"
  | "light";
export const PresetsGetPresetByIdResponseDataUiDesignTokensTheme =
  /*@__PURE__*/ S.String;

export interface PresetsGetPresetByIdResponseDataUiDesignTokens {
  borderRadius: PresetsGetPresetByIdResponseDataUiDesignTokensBorderRadius;
  borderWidth: PresetsGetPresetByIdResponseDataUiDesignTokensBorderWidth;
  colors: PresetsCreateRequestUiDesignTokensColors;
  spacingBase: number;
  theme: PresetsGetPresetByIdResponseDataUiDesignTokensTheme;
  fontFamily?: string | null;
  googleFont?: string | null;
  logo?: string | null;
}
export const PresetsGetPresetByIdResponseDataUiDesignTokens =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      borderRadius:
        PresetsGetPresetByIdResponseDataUiDesignTokensBorderRadius.pipe(
          T.Body("border_radius"),
        ),
      borderWidth:
        PresetsGetPresetByIdResponseDataUiDesignTokensBorderWidth.pipe(
          T.Body("border_width"),
        ),
      colors: PresetsCreateRequestUiDesignTokensColors,
      spacingBase: S.Number.pipe(T.Body("spacing_base")),
      theme: PresetsGetPresetByIdResponseDataUiDesignTokensTheme,
      fontFamily: S.optional(S.NullOr(S.String).pipe(T.Body("font_family"))),
      googleFont: S.optional(S.NullOr(S.String).pipe(T.Body("google_font"))),
      logo: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier: "PresetsGetPresetByIdResponseDataUiDesignTokens",
  }) as any as S.Schema<PresetsGetPresetByIdResponseDataUiDesignTokens>;

export interface PresetsGetPresetByIdResponseDataUi {
  designTokens: PresetsGetPresetByIdResponseDataUiDesignTokens;
  /** Difference between the preset's UI config and the defaults. */
  configDiff?: unknown | null;
}
export const PresetsGetPresetByIdResponseDataUi = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    designTokens: PresetsGetPresetByIdResponseDataUiDesignTokens.pipe(
      T.Body("design_tokens"),
    ),
    configDiff: S.optional(S.NullOr(S.Unknown).pipe(T.Body("config_diff"))),
  }),
).annotate({
  identifier: "PresetsGetPresetByIdResponseDataUi",
}) as any as S.Schema<PresetsGetPresetByIdResponseDataUi>;

export interface PresetsGetPresetByIdResponseData {
  /** ID of the preset */
  id: string;
  config: PresetsGetPresetByIdResponseDataConfig;
  /** Timestamp this preset was created at */
  createdAt: string;
  /** Name of the preset */
  name: string;
  permissions: PresetsGetPresetByIdResponseDataPermissions;
  ui: PresetsGetPresetByIdResponseDataUi;
  /** Timestamp this preset was last updated */
  updatedAt: string;
}
export const PresetsGetPresetByIdResponseData = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    config: PresetsGetPresetByIdResponseDataConfig,
    createdAt: S.String.pipe(T.Body("created_at")),
    name: S.String,
    permissions: PresetsGetPresetByIdResponseDataPermissions,
    ui: PresetsGetPresetByIdResponseDataUi,
    updatedAt: S.String.pipe(T.Body("updated_at")),
  }),
).annotate({
  identifier: "PresetsGetPresetByIdResponseData",
}) as any as S.Schema<PresetsGetPresetByIdResponseData>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface GetPresetByIdPresetResponse {
  /** Data returned by the operation */
  data: PresetsGetPresetByIdResponseData;
}
export const GetPresetByIdPresetResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    data: PresetsGetPresetByIdResponseData,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetPresetByIdPresetResponse",
}) as any as S.Schema<GetPresetByIdPresetResponse>;

export type RecordingsGetRecordingsRequestSortBy = "invokedTime";
export const RecordingsGetRecordingsRequestSortBy = /*@__PURE__*/ S.String;

export type RecordingsGetRecordingsRequestSortOrder = "ASC" | "DESC";
export const RecordingsGetRecordingsRequestSortOrder = /*@__PURE__*/ S.String;

export type RecordingsGetRecordingsRequestStatus =
  | "INVOKED"
  | "RECORDING"
  | "UPLOADING"
  | "UPLOADED"
  | "ERRORED"
  | "PAUSED";
export const RecordingsGetRecordingsRequestStatus = /*@__PURE__*/ S.String;

export type RecordingsGetRecordingsRequestStatusList = Array<
  RecordingsGetRecordingsRequestStatus | (string & {})
>;
export const RecordingsGetRecordingsRequestStatusList = /*@__PURE__*/ S.Array(
  RecordingsGetRecordingsRequestStatus,
) as any as S.Schema<RecordingsGetRecordingsRequestStatusList>;

export interface GetRecordingsRecordingRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  /** The end time range for which you want to retrieve the meetings. The time must be specified in ISO format. */
  endTime?: string;
  /** If passed, only shows expired/non-expired recordings on RealtimeKit's bucket */
  expired?: boolean;
  /** ID of a meeting. Optional. Will limit results to only this meeting if passed. */
  meetingId?: string;
  /** The page number from which you want your page search results to be displayed. */
  pageNo?: number;
  /** Number of results per page */
  perPage?: number;
  /** The search query string. You can search using the meeting ID or title. */
  search?: string;
  sortBy?: RecordingsGetRecordingsRequestSortBy | (string & {});
  sortOrder?: RecordingsGetRecordingsRequestSortOrder | (string & {});
  /** The start time range for which you want to retrieve the meetings. The time must be specified in ISO format. */
  startTime?: string;
  /** Filter by one or more recording status */
  status?: RecordingsGetRecordingsRequestStatusList;
}
export const GetRecordingsRecordingRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    appId: S.String.pipe(T.Label("app_id")),
    endTime: S.optional(S.String.pipe(T.Query("end_time"))),
    expired: S.optional(S.Boolean.pipe(T.Query())),
    meetingId: S.optional(S.String.pipe(T.Query("meeting_id"))),
    pageNo: S.optional(S.Number.pipe(T.Query("page_no"))),
    perPage: S.optional(S.Number.pipe(T.Query("per_page"))),
    search: S.optional(S.String.pipe(T.Query())),
    sortBy: S.optional(
      RecordingsGetRecordingsRequestSortBy.pipe(T.Query("sort_by")),
    ),
    sortOrder: S.optional(
      RecordingsGetRecordingsRequestSortOrder.pipe(T.Query("sort_order")),
    ),
    startTime: S.optional(S.String.pipe(T.Query("start_time"))),
    status: S.optional(
      RecordingsGetRecordingsRequestStatusList.pipe(T.Query()),
    ),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/realtime/kit/{app_id}/recordings",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetRecordingsRecordingRequest",
}) as any as S.Schema<GetRecordingsRecordingRequest>;

export type RecordingsGetRecordingsResponseDataItemStatus =
  | "INVOKED"
  | "RECORDING"
  | "UPLOADING"
  | "UPLOADED"
  | "ERRORED"
  | "PAUSED";
export const RecordingsGetRecordingsResponseDataItemStatus =
  /*@__PURE__*/ S.String;

export type RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigAudioConfigChannel =
  | "mono"
  | "stereo";
export const RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigAudioConfigChannel =
  /*@__PURE__*/ S.String;

export type RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigAudioConfigCodec =
  | "MP3"
  | "AAC";
export const RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigAudioConfigCodec =
  /*@__PURE__*/ S.String;

export interface RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigAudioConfig {
  /** Audio signal pathway within an audio file that carries a specific sound source. */
  channel?: RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigAudioConfigChannel | null;
  /** Codec using which the recording will be encoded. If VP8/VP9 is selected for videoConfig, changing audioConfig is not allowed. In this case, the codec in the audioConfig is automatically set to vorbis. */
  codec?: RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigAudioConfigCodec | null;
  /** Controls whether to export audio file seperately */
  exportFile?: boolean | null;
}
export const RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigAudioConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      channel: S.optional(
        S.NullOr(
          RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigAudioConfigChannel,
        ),
      ),
      codec: S.optional(
        S.NullOr(
          RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigAudioConfigCodec,
        ),
      ),
      exportFile: S.optional(S.NullOr(S.Boolean).pipe(T.Body("export_file"))),
    }),
  ).annotate({
    identifier:
      "RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigAudioConfig",
  }) as any as S.Schema<RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigAudioConfig>;

export type RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigLiveStreamingConfig =
  MeetingsCreateResponseDataRecordingConfigLiveStreamingConfig;
export const RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigLiveStreamingConfig =
  MeetingsCreateResponseDataRecordingConfigLiveStreamingConfig;

export type RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigRealtimekitBucketConfig =
  MeetingsCreateRequestRecordingConfigRealtimekitBucketConfig;
export const RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigRealtimekitBucketConfig =
  MeetingsCreateRequestRecordingConfigRealtimekitBucketConfig;

export type RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigStorageConfigType =
  | "aws"
  | "azure"
  | "digitalocean"
  | "gcs"
  | "sftp";
export const RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigStorageConfigType =
  /*@__PURE__*/ S.String;

export type RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigStorageConfigAuthMethod =
  | "KEY"
  | "PASSWORD";
export const RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigStorageConfigAuthMethod =
  /*@__PURE__*/ S.String;

export interface RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigStorageConfig {
  /** Type of storage media. */
  type: RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigStorageConfigType;
  /** Access key of the storage medium. Access key is not required for the `gcs` storage media type. */
  accessKey?: string | null;
  /** Authentication method used for "sftp" type storage medium */
  authMethod?: RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigStorageConfigAuthMethod | null;
  /** Name of the storage medium's bucket. */
  bucket?: string | null;
  /** SSH destination server host for SFTP type storage medium */
  host?: string | null;
  /** SSH destination server password for SFTP type storage medium when auth_method is "PASSWORD". If auth_method is "KEY", this specifies the password for the ssh private key. */
  password?: string | null;
  /** Path relative to the bucket root at which the recording will be placed. */
  path?: string | null;
  /** SSH destination server port for SFTP type storage medium */
  port?: number | null;
  /** Private key used to login to destination SSH server for SFTP type storage medium, when auth_method used is "KEY" */
  privateKey?: string | null;
  /** Region of the storage medium. */
  region?: string | null;
  /** Secret key of the storage medium. Similar to `access_key`, it is only writeable by clients, not readable. */
  secret?: string | null;
  /** SSH destination server username for SFTP type storage medium */
  username?: string | null;
}
export const RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigStorageConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigStorageConfigType,
      accessKey: S.optional(S.NullOr(S.String).pipe(T.Body("access_key"))),
      authMethod: S.optional(
        S.NullOr(
          RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigStorageConfigAuthMethod,
        ).pipe(T.Body("auth_method")),
      ),
      bucket: S.optional(S.NullOr(S.String)),
      host: S.optional(S.NullOr(S.String)),
      password: S.optional(S.NullOr(S.String)),
      path: S.optional(S.NullOr(S.String)),
      port: S.optional(S.NullOr(S.Number)),
      privateKey: S.optional(S.NullOr(S.String).pipe(T.Body("private_key"))),
      region: S.optional(S.NullOr(S.String)),
      secret: S.optional(S.NullOr(S.String)),
      username: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier:
      "RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigStorageConfig",
  }) as any as S.Schema<RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigStorageConfig>;

export type RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigVideoConfigCodec =
  | "H264"
  | "VP8";
export const RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigVideoConfigCodec =
  /*@__PURE__*/ S.String;

export type RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigVideoConfigWatermarkPosition =
  | "left top"
  | "right top"
  | "left bottom"
  | "right bottom";
export const RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigVideoConfigWatermarkPosition =
  /*@__PURE__*/ S.String;

export type RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigVideoConfigWatermarkSize =
  MeetingsCreateResponseDataRecordingConfigVideoConfigWatermarkSize;
export const RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigVideoConfigWatermarkSize =
  MeetingsCreateResponseDataRecordingConfigVideoConfigWatermarkSize;

export interface RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigVideoConfigWatermark {
  /** Position of the watermark */
  position?: RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigVideoConfigWatermarkPosition | null;
  /** Size of the watermark */
  size?: MeetingsCreateResponseDataRecordingConfigVideoConfigWatermarkSize | null;
  /** URL of the watermark image */
  url?: string | null;
}
export const RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigVideoConfigWatermark =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      position: S.optional(
        S.NullOr(
          RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigVideoConfigWatermarkPosition,
        ),
      ),
      size: S.optional(
        S.NullOr(
          MeetingsCreateResponseDataRecordingConfigVideoConfigWatermarkSize,
        ),
      ),
      url: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier:
      "RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigVideoConfigWatermark",
  }) as any as S.Schema<RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigVideoConfigWatermark>;

export interface RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigVideoConfig {
  /** Codec using which the recording will be encoded. */
  codec?: RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigVideoConfigCodec | null;
  /** Controls whether to export video file seperately */
  exportFile?: boolean | null;
  /** Height of the recording video in pixels */
  height?: number | null;
  /** Watermark to be added to the recording */
  watermark?: RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigVideoConfigWatermark | null;
  /** Width of the recording video in pixels */
  width?: number | null;
}
export const RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigVideoConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      codec: S.optional(
        S.NullOr(
          RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigVideoConfigCodec,
        ),
      ),
      exportFile: S.optional(S.NullOr(S.Boolean).pipe(T.Body("export_file"))),
      height: S.optional(S.NullOr(S.Number)),
      watermark: S.optional(
        S.NullOr(
          RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigVideoConfigWatermark,
        ),
      ),
      width: S.optional(S.NullOr(S.Number)),
    }),
  ).annotate({
    identifier:
      "RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigVideoConfig",
  }) as any as S.Schema<RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigVideoConfig>;

export interface RecordingsGetRecordingsResponseDataItemMeetingRecordingConfig {
  /** Object containing configuration regarding the audio that is being recorded. */
  audioConfig?: RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigAudioConfig | null;
  /** Adds a prefix to the beginning of the file name of the recording. */
  fileNamePrefix?: string | null;
  liveStreamingConfig?: MeetingsCreateResponseDataRecordingConfigLiveStreamingConfig | null;
  /** Specifies the maximum duration for recording in seconds, ranging from a minimum of 60 seconds to a maximum of 24 hours. */
  maxSeconds?: number | null;
  realtimekitBucketConfig?: MeetingsCreateRequestRecordingConfigRealtimekitBucketConfig | null;
  storageConfig?: RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigStorageConfig | null;
  videoConfig?: RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigVideoConfig | null;
}
export const RecordingsGetRecordingsResponseDataItemMeetingRecordingConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      audioConfig: S.optional(
        S.NullOr(
          RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigAudioConfig,
        ).pipe(T.Body("audio_config")),
      ),
      fileNamePrefix: S.optional(
        S.NullOr(S.String).pipe(T.Body("file_name_prefix")),
      ),
      liveStreamingConfig: S.optional(
        S.NullOr(
          MeetingsCreateResponseDataRecordingConfigLiveStreamingConfig,
        ).pipe(T.Body("live_streaming_config")),
      ),
      maxSeconds: S.optional(S.NullOr(S.Number).pipe(T.Body("max_seconds"))),
      realtimekitBucketConfig: S.optional(
        S.NullOr(
          MeetingsCreateRequestRecordingConfigRealtimekitBucketConfig,
        ).pipe(T.Body("realtimekit_bucket_config")),
      ),
      storageConfig: S.optional(
        S.NullOr(
          RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigStorageConfig,
        ).pipe(T.Body("storage_config")),
      ),
      videoConfig: S.optional(
        S.NullOr(
          RecordingsGetRecordingsResponseDataItemMeetingRecordingConfigVideoConfig,
        ).pipe(T.Body("video_config")),
      ),
    }),
  ).annotate({
    identifier: "RecordingsGetRecordingsResponseDataItemMeetingRecordingConfig",
  }) as any as S.Schema<RecordingsGetRecordingsResponseDataItemMeetingRecordingConfig>;

export type RecordingsGetRecordingsResponseDataItemMeetingStatus =
  | "ACTIVE"
  | "INACTIVE";
export const RecordingsGetRecordingsResponseDataItemMeetingStatus =
  /*@__PURE__*/ S.String;

export interface RecordingsGetRecordingsResponseDataItemMeeting {
  /** ID of the meeting. */
  id: string;
  /** Timestamp the object was created at. The time is returned in ISO format. */
  createdAt: string;
  /** Timestamp the object was updated at. The time is returned in ISO format. */
  updatedAt: string;
  /** Specifies if the meeting should start getting livestreamed on start. */
  liveStreamOnStart?: boolean | null;
  /** Specifies if Chat within a meeting should persist for a week. */
  persistChat?: boolean | null;
  /** Specifies if the meeting should start getting recorded as soon as someone joins the meeting. */
  recordOnStart?: boolean | null;
  /** Recording Configurations to be used for this meeting. This level of configs takes higher preference over App level configs on the RealtimeKit developer portal. */
  recordingConfig?: RecordingsGetRecordingsResponseDataItemMeetingRecordingConfig | null;
  /** Time in seconds, for which a session remains active, after the last participant has left the meeting. */
  sessionKeepAliveTimeInSecs?: number | null;
  /** Whether the meeting is `ACTIVE` or `INACTIVE`. Users will not be able to join an `INACTIVE` meeting. */
  status?: RecordingsGetRecordingsResponseDataItemMeetingStatus | null;
  /** Automatically generate summary of meetings using transcripts. Requires Transcriptions to be enabled, and can be retrieved via Webhooks or summary API. */
  summarizeOnEnd?: boolean | null;
  /** Title of the meeting. */
  title?: string | null;
  /** Automatically generate transcripts when the meeting ends. */
  transcribeOnEnd?: boolean | null;
}
export const RecordingsGetRecordingsResponseDataItemMeeting =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      createdAt: S.String.pipe(T.Body("created_at")),
      updatedAt: S.String.pipe(T.Body("updated_at")),
      liveStreamOnStart: S.optional(
        S.NullOr(S.Boolean).pipe(T.Body("live_stream_on_start")),
      ),
      persistChat: S.optional(S.NullOr(S.Boolean).pipe(T.Body("persist_chat"))),
      recordOnStart: S.optional(
        S.NullOr(S.Boolean).pipe(T.Body("record_on_start")),
      ),
      recordingConfig: S.optional(
        S.NullOr(
          RecordingsGetRecordingsResponseDataItemMeetingRecordingConfig,
        ).pipe(T.Body("recording_config")),
      ),
      sessionKeepAliveTimeInSecs: S.optional(
        S.NullOr(S.Number).pipe(T.Body("session_keep_alive_time_in_secs")),
      ),
      status: S.optional(
        S.NullOr(RecordingsGetRecordingsResponseDataItemMeetingStatus),
      ),
      summarizeOnEnd: S.optional(
        S.NullOr(S.Boolean).pipe(T.Body("summarize_on_end")),
      ),
      title: S.optional(S.NullOr(S.String)),
      transcribeOnEnd: S.optional(
        S.NullOr(S.Boolean).pipe(T.Body("transcribe_on_end")),
      ),
    }),
  ).annotate({
    identifier: "RecordingsGetRecordingsResponseDataItemMeeting",
  }) as any as S.Schema<RecordingsGetRecordingsResponseDataItemMeeting>;

export type RecordingsGetRecordingsResponseDataItemStorageConfigType =
  | "aws"
  | "azure"
  | "digitalocean"
  | "gcs"
  | "sftp";
export const RecordingsGetRecordingsResponseDataItemStorageConfigType =
  /*@__PURE__*/ S.String;

export type RecordingsGetRecordingsResponseDataItemStorageConfigAuthMethod =
  | "KEY"
  | "PASSWORD";
export const RecordingsGetRecordingsResponseDataItemStorageConfigAuthMethod =
  /*@__PURE__*/ S.String;

export interface RecordingsGetRecordingsResponseDataItemStorageConfig {
  /** Type of storage media. */
  type: RecordingsGetRecordingsResponseDataItemStorageConfigType;
  /** Access key of the storage medium. Access key is not required for the `gcs` storage media type. */
  accessKey?: string | null;
  /** Authentication method used for "sftp" type storage medium */
  authMethod?: RecordingsGetRecordingsResponseDataItemStorageConfigAuthMethod | null;
  /** Name of the storage medium's bucket. */
  bucket?: string | null;
  /** SSH destination server host for SFTP type storage medium */
  host?: string | null;
  /** SSH destination server password for SFTP type storage medium when auth_method is "PASSWORD". If auth_method is "KEY", this specifies the password for the ssh private key. */
  password?: string | null;
  /** Path relative to the bucket root at which the recording will be placed. */
  path?: string | null;
  /** SSH destination server port for SFTP type storage medium */
  port?: number | null;
  /** Private key used to login to destination SSH server for SFTP type storage medium, when auth_method used is "KEY" */
  privateKey?: string | null;
  /** Region of the storage medium. */
  region?: string | null;
  /** Secret key of the storage medium. Similar to `access_key`, it is only writeable by clients, not readable. */
  secret?: string | null;
  /** SSH destination server username for SFTP type storage medium */
  username?: string | null;
}
export const RecordingsGetRecordingsResponseDataItemStorageConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: RecordingsGetRecordingsResponseDataItemStorageConfigType,
      accessKey: S.optional(S.NullOr(S.String).pipe(T.Body("access_key"))),
      authMethod: S.optional(
        S.NullOr(
          RecordingsGetRecordingsResponseDataItemStorageConfigAuthMethod,
        ).pipe(T.Body("auth_method")),
      ),
      bucket: S.optional(S.NullOr(S.String)),
      host: S.optional(S.NullOr(S.String)),
      password: S.optional(S.NullOr(S.String)),
      path: S.optional(S.NullOr(S.String)),
      port: S.optional(S.NullOr(S.Number)),
      privateKey: S.optional(S.NullOr(S.String).pipe(T.Body("private_key"))),
      region: S.optional(S.NullOr(S.String)),
      secret: S.optional(S.NullOr(S.String)),
      username: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier: "RecordingsGetRecordingsResponseDataItemStorageConfig",
  }) as any as S.Schema<RecordingsGetRecordingsResponseDataItemStorageConfig>;

export interface RecordingsGetRecordingsResponseDataItem {
  /** ID of the recording */
  id: string;
  /** If the audio_config is passed, the URL for downloading the audio recording is returned. */
  audioDownloadUrl: string;
  /** URL where the recording can be downloaded. */
  downloadUrl: string;
  /** Timestamp when the download URL expires. */
  downloadUrlExpiry: string;
  /** File size of the recording, in bytes. */
  fileSize: number;
  /** Timestamp when this recording was invoked. */
  invokedTime: string;
  /** File name of the recording. */
  outputFileName: string;
  /** ID of the meeting session this recording is for. */
  sessionId: string;
  /** Timestamp when this recording actually started after being invoked. Usually a few seconds after `invoked_time`. */
  startedTime: string;
  /** Current status of the recording. */
  status: RecordingsGetRecordingsResponseDataItemStatus;
  /** Timestamp when this recording was stopped. Optional; is present only when the recording has actually been stopped. */
  stoppedTime: string;
  meeting?: RecordingsGetRecordingsResponseDataItemMeeting | null;
  /** Total recording time in seconds. */
  recordingDuration?: number | null;
  storageConfig?: RecordingsGetRecordingsResponseDataItemStorageConfig | null;
}
export const RecordingsGetRecordingsResponseDataItem = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.String,
      audioDownloadUrl: S.String.pipe(T.Body("audio_download_url")),
      downloadUrl: S.String.pipe(T.Body("download_url")),
      downloadUrlExpiry: S.String.pipe(T.Body("download_url_expiry")),
      fileSize: S.Number.pipe(T.Body("file_size")),
      invokedTime: S.String.pipe(T.Body("invoked_time")),
      outputFileName: S.String.pipe(T.Body("output_file_name")),
      sessionId: S.String.pipe(T.Body("session_id")),
      startedTime: S.String.pipe(T.Body("started_time")),
      status: RecordingsGetRecordingsResponseDataItemStatus,
      stoppedTime: S.String.pipe(T.Body("stopped_time")),
      meeting: S.optional(
        S.NullOr(RecordingsGetRecordingsResponseDataItemMeeting),
      ),
      recordingDuration: S.optional(
        S.NullOr(S.Number).pipe(T.Body("recording_duration")),
      ),
      storageConfig: S.optional(
        S.NullOr(RecordingsGetRecordingsResponseDataItemStorageConfig).pipe(
          T.Body("storage_config"),
        ),
      ),
    }),
).annotate({
  identifier: "RecordingsGetRecordingsResponseDataItem",
}) as any as S.Schema<RecordingsGetRecordingsResponseDataItem>;

export type RecordingsGetRecordingsResponseDataList =
  Array<RecordingsGetRecordingsResponseDataItem>;
export const RecordingsGetRecordingsResponseDataList = /*@__PURE__*/ S.Array(
  RecordingsGetRecordingsResponseDataItem,
) as any as S.Schema<RecordingsGetRecordingsResponseDataList>;

export type RecordingsGetRecordingsResponsePaging = MeetingsGetResponsePaging;
export const RecordingsGetRecordingsResponsePaging = MeetingsGetResponsePaging;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface GetRecordingsRecordingResponse {
  data: RecordingsGetRecordingsResponseDataList;
  paging: MeetingsGetResponsePaging;
}
export const GetRecordingsRecordingResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    data: RecordingsGetRecordingsResponseDataList,
    paging: MeetingsGetResponsePaging,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetRecordingsRecordingResponse",
}) as any as S.Schema<GetRecordingsRecordingResponse>;

export interface GetSessionChatSessionRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  sessionId: string;
}
export const GetSessionChatSessionRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    appId: S.String.pipe(T.Label("app_id")),
    sessionId: S.String.pipe(T.Label("session_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/realtime/kit/{app_id}/sessions/{session_id}/chat",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetSessionChatSessionRequest",
}) as any as S.Schema<GetSessionChatSessionRequest>;

export interface SessionsGetSessionChatResponseData {
  /** URL where the chat logs can be downloaded */
  chatDownloadUrl: string;
  /** Time when the download URL will expire */
  chatDownloadUrlExpiry: string;
}
export const SessionsGetSessionChatResponseData = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    chatDownloadUrl: S.String.pipe(T.Body("chat_download_url")),
    chatDownloadUrlExpiry: S.String.pipe(T.Body("chat_download_url_expiry")),
  }),
).annotate({
  identifier: "SessionsGetSessionChatResponseData",
}) as any as S.Schema<SessionsGetSessionChatResponseData>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface GetSessionChatSessionResponse {
  data?: SessionsGetSessionChatResponseData | null;
}
export const GetSessionChatSessionResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    data: S.optional(S.NullOr(SessionsGetSessionChatResponseData)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetSessionChatSessionResponse",
}) as any as S.Schema<GetSessionChatSessionResponse>;

export interface GetSessionDetailsSessionRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  sessionId: string;
  /** List all breakout rooms */
  includeBreakoutRooms?: boolean;
}
export const GetSessionDetailsSessionRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    appId: S.String.pipe(T.Label("app_id")),
    sessionId: S.String.pipe(T.Label("session_id")),
    includeBreakoutRooms: S.optional(
      S.Boolean.pipe(T.Query("include_breakout_rooms")),
    ),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/realtime/kit/{app_id}/sessions/{session_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetSessionDetailsSessionRequest",
}) as any as S.Schema<GetSessionDetailsSessionRequest>;

export type SessionsGetSessionDetailsResponseDataStatus = "LIVE" | "ENDED";
export const SessionsGetSessionDetailsResponseDataStatus =
  /*@__PURE__*/ S.String;

export type SessionsGetSessionDetailsResponseDataType =
  | "meeting"
  | "livestream"
  | "participant";
export const SessionsGetSessionDetailsResponseDataType = /*@__PURE__*/ S.String;

export type SessionsGetSessionDetailsResponseDataBreakoutRoomsList =
  Array<unknown>;
export const SessionsGetSessionDetailsResponseDataBreakoutRoomsList =
  /*@__PURE__*/ S.Array(
    S.Unknown,
  ) as any as S.Schema<SessionsGetSessionDetailsResponseDataBreakoutRoomsList>;

export interface SessionsGetSessionDetailsResponseData {
  /** ID of the session */
  id: string;
  /** ID of the meeting this session is associated with. In the case of V2 meetings, it is always a UUID. In V1 meetings, it is a room name of the form `abcdef-ghijkl` */
  associatedId: string;
  /** timestamp when session created */
  createdAt: string;
  /** number of participants currently in the session */
  liveParticipants: number;
  /** number of maximum participants that were in the session */
  maxConcurrentParticipants: number;
  /** Title of the meeting this session belongs to */
  meetingDisplayName: string;
  /** number of minutes consumed since the session started */
  minutesConsumed: number;
  /** App id that hosted this session */
  organizationId: string;
  /** timestamp when session started */
  startedAt: string;
  /** current status of session */
  status: SessionsGetSessionDetailsResponseDataStatus;
  /** type of session */
  type: SessionsGetSessionDetailsResponseDataType;
  /** timestamp when session was last updated */
  updatedAt: string;
  breakoutRooms?: SessionsGetSessionDetailsResponseDataBreakoutRoomsList | null;
  /** timestamp when session ended */
  endedAt?: string | null;
}
export const SessionsGetSessionDetailsResponseData = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.String,
      associatedId: S.String.pipe(T.Body("associated_id")),
      createdAt: S.String.pipe(T.Body("created_at")),
      liveParticipants: S.Number.pipe(T.Body("live_participants")),
      maxConcurrentParticipants: S.Number.pipe(
        T.Body("max_concurrent_participants"),
      ),
      meetingDisplayName: S.String.pipe(T.Body("meeting_display_name")),
      minutesConsumed: S.Number.pipe(T.Body("minutes_consumed")),
      organizationId: S.String.pipe(T.Body("organization_id")),
      startedAt: S.String.pipe(T.Body("started_at")),
      status: SessionsGetSessionDetailsResponseDataStatus,
      type: SessionsGetSessionDetailsResponseDataType,
      updatedAt: S.String.pipe(T.Body("updated_at")),
      breakoutRooms: S.optional(
        S.NullOr(SessionsGetSessionDetailsResponseDataBreakoutRoomsList).pipe(
          T.Body("breakout_rooms"),
        ),
      ),
      endedAt: S.optional(S.NullOr(S.String).pipe(T.Body("ended_at"))),
    }),
).annotate({
  identifier: "SessionsGetSessionDetailsResponseData",
}) as any as S.Schema<SessionsGetSessionDetailsResponseData>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface GetSessionDetailsSessionResponse {
  data?: SessionsGetSessionDetailsResponseData | null;
}
export const GetSessionDetailsSessionResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    data: S.optional(S.NullOr(SessionsGetSessionDetailsResponseData)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetSessionDetailsSessionResponse",
}) as any as S.Schema<GetSessionDetailsSessionResponse>;

export interface GetSessionParticipantDetailsSessionRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  sessionId: string;
  participantId: string;
  /** if true, response includes all the peer events of participant. */
  includePeerEvents?: boolean;
}
export const GetSessionParticipantDetailsSessionRequest =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      accountId: S.String.pipe(T.Label("account_id")),
      appId: S.String.pipe(T.Label("app_id")),
      sessionId: S.String.pipe(T.Label("session_id")),
      participantId: S.String.pipe(T.Label("participant_id")),
      includePeerEvents: S.optional(
        S.Boolean.pipe(T.Query("include_peer_events")),
      ),
    })
      .pipe(
        T.Http({
          method: "GET",
          uri: "/accounts/{account_id}/realtime/kit/{app_id}/sessions/{session_id}/participants/{participant_id}",
          code: 200,
        }),
      )
      .pipe(T.KeyDictionary(KEY_DICTIONARY)),
  ).annotate({
    identifier: "GetSessionParticipantDetailsSessionRequest",
  }) as any as S.Schema<GetSessionParticipantDetailsSessionRequest>;

export type SessionsGetSessionParticipantDetailsResponseDataParticipantPeerEventsItemEventName =
  | "PEER_CREATED"
  | "PEER_JOINING"
  | "PEER_LEAVING";
export const SessionsGetSessionParticipantDetailsResponseDataParticipantPeerEventsItemEventName =
  /*@__PURE__*/ S.String;

export type SessionsGetSessionParticipantDetailsResponseDataParticipantPeerEventsItemPresetViewType =
  | "GROUP_CALL"
  | "WEBINAR"
  | "AUDIO_ROOM"
  | "LIVESTREAM"
  | "CHAT";
export const SessionsGetSessionParticipantDetailsResponseDataParticipantPeerEventsItemPresetViewType =
  /*@__PURE__*/ S.String;

export interface SessionsGetSessionParticipantDetailsResponseDataParticipantPeerEventsItem {
  /** ID of the peer event. */
  id?: string | null;
  /** Timestamp when this peer event was created. */
  createdAt?: string | null;
  /** Name of the peer event. */
  eventName?: SessionsGetSessionParticipantDetailsResponseDataParticipantPeerEventsItemEventName | null;
  /** Minutes consumed attributed to this event. */
  minutesConsumed?: number | null;
  /** ID of the participant this event belongs to. */
  participantId?: string | null;
  /** Peer ID this event belongs to. */
  peerId?: string | null;
  /** View type of the preset associated with the peer. */
  presetViewType?: SessionsGetSessionParticipantDetailsResponseDataParticipantPeerEventsItemPresetViewType | null;
  /** ID of the session this event belongs to. */
  sessionId?: string | null;
  /** ID of the socket session associated with this event. */
  socketSessionId?: string | null;
  /** Timestamp when this peer event was last updated. */
  updatedAt?: string | null;
}
export const SessionsGetSessionParticipantDetailsResponseDataParticipantPeerEventsItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.optional(S.NullOr(S.String)),
      createdAt: S.optional(S.NullOr(S.String).pipe(T.Body("created_at"))),
      eventName: S.optional(
        S.NullOr(
          SessionsGetSessionParticipantDetailsResponseDataParticipantPeerEventsItemEventName,
        ).pipe(T.Body("event_name")),
      ),
      minutesConsumed: S.optional(
        S.NullOr(S.Number).pipe(T.Body("minutes_consumed")),
      ),
      participantId: S.optional(
        S.NullOr(S.String).pipe(T.Body("participant_id")),
      ),
      peerId: S.optional(S.NullOr(S.String).pipe(T.Body("peer_id"))),
      presetViewType: S.optional(
        S.NullOr(
          SessionsGetSessionParticipantDetailsResponseDataParticipantPeerEventsItemPresetViewType,
        ).pipe(T.Body("preset_view_type")),
      ),
      sessionId: S.optional(S.NullOr(S.String).pipe(T.Body("session_id"))),
      socketSessionId: S.optional(
        S.NullOr(S.String).pipe(T.Body("socket_session_id")),
      ),
      updatedAt: S.optional(S.NullOr(S.String).pipe(T.Body("updated_at"))),
    }),
  ).annotate({
    identifier:
      "SessionsGetSessionParticipantDetailsResponseDataParticipantPeerEventsItem",
  }) as any as S.Schema<SessionsGetSessionParticipantDetailsResponseDataParticipantPeerEventsItem>;

export type SessionsGetSessionParticipantDetailsResponseDataParticipantPeerEventsList =
  Array<SessionsGetSessionParticipantDetailsResponseDataParticipantPeerEventsItem>;
export const SessionsGetSessionParticipantDetailsResponseDataParticipantPeerEventsList =
  /*@__PURE__*/ S.Array(
    SessionsGetSessionParticipantDetailsResponseDataParticipantPeerEventsItem,
  ) as any as S.Schema<SessionsGetSessionParticipantDetailsResponseDataParticipantPeerEventsList>;

export interface SessionsGetSessionParticipantDetailsResponseDataParticipant {
  /** Participant ID. This maps to the corresponding peerId. */
  id?: string | null;
  /** timestamp when this participant was created. */
  createdAt?: string | null;
  /** ID passed by client to create this participant. */
  customParticipantId?: string | null;
  /** Display name of participant when joining the session. */
  displayName?: string | null;
  /** number of minutes for which the participant was in the session. */
  duration?: number | null;
  /** timestamp at which participant joined the session. */
  joinedAt?: string | null;
  /** timestamp at which participant left the session. */
  leftAt?: string | null;
  /** Connection lifecycle events for the participant's peer. Only included when `include_peer_events` is true. */
  peerEvents?: SessionsGetSessionParticipantDetailsResponseDataParticipantPeerEventsList | null;
  /** Name of the preset associated with the participant. */
  presetName?: string | null;
  /** timestamp when this participant's data was last updated. */
  updatedAt?: string | null;
  /** User id for this participant. */
  userId?: string | null;
}
export const SessionsGetSessionParticipantDetailsResponseDataParticipant =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.optional(S.NullOr(S.String)),
      createdAt: S.optional(S.NullOr(S.String).pipe(T.Body("created_at"))),
      customParticipantId: S.optional(
        S.NullOr(S.String).pipe(T.Body("custom_participant_id")),
      ),
      displayName: S.optional(S.NullOr(S.String).pipe(T.Body("display_name"))),
      duration: S.optional(S.NullOr(S.Number)),
      joinedAt: S.optional(S.NullOr(S.String).pipe(T.Body("joined_at"))),
      leftAt: S.optional(S.NullOr(S.String).pipe(T.Body("left_at"))),
      peerEvents: S.optional(
        S.NullOr(
          SessionsGetSessionParticipantDetailsResponseDataParticipantPeerEventsList,
        ).pipe(T.Body("peer_events")),
      ),
      presetName: S.optional(S.NullOr(S.String).pipe(T.Body("preset_name"))),
      updatedAt: S.optional(S.NullOr(S.String).pipe(T.Body("updated_at"))),
      userId: S.optional(S.NullOr(S.String).pipe(T.Body("user_id"))),
    }),
  ).annotate({
    identifier: "SessionsGetSessionParticipantDetailsResponseDataParticipant",
  }) as any as S.Schema<SessionsGetSessionParticipantDetailsResponseDataParticipant>;

export interface SessionsGetSessionParticipantDetailsResponseData {
  participant?: SessionsGetSessionParticipantDetailsResponseDataParticipant | null;
}
export const SessionsGetSessionParticipantDetailsResponseData =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      participant: S.optional(
        S.NullOr(SessionsGetSessionParticipantDetailsResponseDataParticipant),
      ),
    }),
  ).annotate({
    identifier: "SessionsGetSessionParticipantDetailsResponseData",
  }) as any as S.Schema<SessionsGetSessionParticipantDetailsResponseData>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface GetSessionParticipantDetailsSessionResponse {
  data?: SessionsGetSessionParticipantDetailsResponseData | null;
}
export const GetSessionParticipantDetailsSessionResponse =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      data: S.optional(
        S.NullOr(SessionsGetSessionParticipantDetailsResponseData),
      ),
    }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
  ).annotate({
    identifier: "GetSessionParticipantDetailsSessionResponse",
  }) as any as S.Schema<GetSessionParticipantDetailsSessionResponse>;

export type SessionsGetSessionParticipantsRequestSortBy =
  | "joinedAt"
  | "duration";
export const SessionsGetSessionParticipantsRequestSortBy =
  /*@__PURE__*/ S.String;

export type SessionsGetSessionParticipantsRequestSortOrder = "ASC" | "DESC";
export const SessionsGetSessionParticipantsRequestSortOrder =
  /*@__PURE__*/ S.String;

export type SessionsGetSessionParticipantsRequestView = "raw" | "consolidated";
export const SessionsGetSessionParticipantsRequestView = /*@__PURE__*/ S.String;

export interface GetSessionParticipantsSessionRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  sessionId: string;
  /** if true, response includes all the peer events of participants. */
  includePeerEvents?: boolean;
  /** The page number from which you want your page search results to be displayed. */
  pageNo?: number;
  /** Number of results per page */
  perPage?: number;
  /** The search query string. You can search using participant ID, custom participant ID, or display name. */
  search?: string;
  sortBy?: SessionsGetSessionParticipantsRequestSortBy | (string & {});
  sortOrder?: SessionsGetSessionParticipantsRequestSortOrder | (string & {});
  /** In breakout room sessions, the view parameter can be set to `raw` for session specific duration for participants or `consolidated` to accumulate breakout room durations. */
  view?: SessionsGetSessionParticipantsRequestView | (string & {});
}
export const GetSessionParticipantsSessionRequest = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      accountId: S.String.pipe(T.Label("account_id")),
      appId: S.String.pipe(T.Label("app_id")),
      sessionId: S.String.pipe(T.Label("session_id")),
      includePeerEvents: S.optional(
        S.Boolean.pipe(T.Query("include_peer_events")),
      ),
      pageNo: S.optional(S.Number.pipe(T.Query("page_no"))),
      perPage: S.optional(S.Number.pipe(T.Query("per_page"))),
      search: S.optional(S.String.pipe(T.Query())),
      sortBy: S.optional(
        SessionsGetSessionParticipantsRequestSortBy.pipe(T.Query("sort_by")),
      ),
      sortOrder: S.optional(
        SessionsGetSessionParticipantsRequestSortOrder.pipe(
          T.Query("sort_order"),
        ),
      ),
      view: S.optional(
        SessionsGetSessionParticipantsRequestView.pipe(T.Query()),
      ),
    })
      .pipe(
        T.Http({
          method: "GET",
          uri: "/accounts/{account_id}/realtime/kit/{app_id}/sessions/{session_id}/participants",
          code: 200,
        }),
      )
      .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetSessionParticipantsSessionRequest",
}) as any as S.Schema<GetSessionParticipantsSessionRequest>;

export type SessionsGetSessionParticipantsResponseDataParticipantsItemPeerEventsItemEventName =
  | "PEER_CREATED"
  | "PEER_JOINING"
  | "PEER_LEAVING";
export const SessionsGetSessionParticipantsResponseDataParticipantsItemPeerEventsItemEventName =
  /*@__PURE__*/ S.String;

export type SessionsGetSessionParticipantsResponseDataParticipantsItemPeerEventsItemPresetViewType =
  | "GROUP_CALL"
  | "WEBINAR"
  | "AUDIO_ROOM"
  | "LIVESTREAM"
  | "CHAT";
export const SessionsGetSessionParticipantsResponseDataParticipantsItemPeerEventsItemPresetViewType =
  /*@__PURE__*/ S.String;

export interface SessionsGetSessionParticipantsResponseDataParticipantsItemPeerEventsItem {
  /** ID of the peer event. */
  id?: string | null;
  /** Timestamp when this peer event was created. */
  createdAt?: string | null;
  /** Name of the peer event. */
  eventName?: SessionsGetSessionParticipantsResponseDataParticipantsItemPeerEventsItemEventName | null;
  /** Minutes consumed attributed to this event. */
  minutesConsumed?: number | null;
  /** ID of the participant this event belongs to. */
  participantId?: string | null;
  /** Peer ID this event belongs to. */
  peerId?: string | null;
  /** View type of the preset associated with the peer. */
  presetViewType?: SessionsGetSessionParticipantsResponseDataParticipantsItemPeerEventsItemPresetViewType | null;
  /** ID of the session this event belongs to. */
  sessionId?: string | null;
  /** ID of the socket session associated with this event. */
  socketSessionId?: string | null;
  /** Timestamp when this peer event was last updated. */
  updatedAt?: string | null;
}
export const SessionsGetSessionParticipantsResponseDataParticipantsItemPeerEventsItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.optional(S.NullOr(S.String)),
      createdAt: S.optional(S.NullOr(S.String).pipe(T.Body("created_at"))),
      eventName: S.optional(
        S.NullOr(
          SessionsGetSessionParticipantsResponseDataParticipantsItemPeerEventsItemEventName,
        ).pipe(T.Body("event_name")),
      ),
      minutesConsumed: S.optional(
        S.NullOr(S.Number).pipe(T.Body("minutes_consumed")),
      ),
      participantId: S.optional(
        S.NullOr(S.String).pipe(T.Body("participant_id")),
      ),
      peerId: S.optional(S.NullOr(S.String).pipe(T.Body("peer_id"))),
      presetViewType: S.optional(
        S.NullOr(
          SessionsGetSessionParticipantsResponseDataParticipantsItemPeerEventsItemPresetViewType,
        ).pipe(T.Body("preset_view_type")),
      ),
      sessionId: S.optional(S.NullOr(S.String).pipe(T.Body("session_id"))),
      socketSessionId: S.optional(
        S.NullOr(S.String).pipe(T.Body("socket_session_id")),
      ),
      updatedAt: S.optional(S.NullOr(S.String).pipe(T.Body("updated_at"))),
    }),
  ).annotate({
    identifier:
      "SessionsGetSessionParticipantsResponseDataParticipantsItemPeerEventsItem",
  }) as any as S.Schema<SessionsGetSessionParticipantsResponseDataParticipantsItemPeerEventsItem>;

export type SessionsGetSessionParticipantsResponseDataParticipantsItemPeerEventsList =
  Array<SessionsGetSessionParticipantsResponseDataParticipantsItemPeerEventsItem>;
export const SessionsGetSessionParticipantsResponseDataParticipantsItemPeerEventsList =
  /*@__PURE__*/ S.Array(
    SessionsGetSessionParticipantsResponseDataParticipantsItemPeerEventsItem,
  ) as any as S.Schema<SessionsGetSessionParticipantsResponseDataParticipantsItemPeerEventsList>;

export interface SessionsGetSessionParticipantsResponseDataParticipantsItem {
  /** Participant ID. This maps to the corresponding peerId. */
  id?: string | null;
  /** timestamp when this participant was created. */
  createdAt?: string | null;
  /** ID passed by client to create this participant. */
  customParticipantId?: string | null;
  /** Display name of participant when joining the session. */
  displayName?: string | null;
  /** number of minutes for which the participant was in the session. */
  duration?: number | null;
  /** timestamp at which participant joined the session. */
  joinedAt?: string | null;
  /** timestamp at which participant left the session. */
  leftAt?: string | null;
  /** Connection lifecycle events for the participant's peer. Only included when `include_peer_events` is true. */
  peerEvents?: SessionsGetSessionParticipantsResponseDataParticipantsItemPeerEventsList | null;
  /** Name of the preset associated with the participant. */
  presetName?: string | null;
  /** timestamp when this participant's data was last updated. */
  updatedAt?: string | null;
  /** User id for this participant. */
  userId?: string | null;
}
export const SessionsGetSessionParticipantsResponseDataParticipantsItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.optional(S.NullOr(S.String)),
      createdAt: S.optional(S.NullOr(S.String).pipe(T.Body("created_at"))),
      customParticipantId: S.optional(
        S.NullOr(S.String).pipe(T.Body("custom_participant_id")),
      ),
      displayName: S.optional(S.NullOr(S.String).pipe(T.Body("display_name"))),
      duration: S.optional(S.NullOr(S.Number)),
      joinedAt: S.optional(S.NullOr(S.String).pipe(T.Body("joined_at"))),
      leftAt: S.optional(S.NullOr(S.String).pipe(T.Body("left_at"))),
      peerEvents: S.optional(
        S.NullOr(
          SessionsGetSessionParticipantsResponseDataParticipantsItemPeerEventsList,
        ).pipe(T.Body("peer_events")),
      ),
      presetName: S.optional(S.NullOr(S.String).pipe(T.Body("preset_name"))),
      updatedAt: S.optional(S.NullOr(S.String).pipe(T.Body("updated_at"))),
      userId: S.optional(S.NullOr(S.String).pipe(T.Body("user_id"))),
    }),
  ).annotate({
    identifier: "SessionsGetSessionParticipantsResponseDataParticipantsItem",
  }) as any as S.Schema<SessionsGetSessionParticipantsResponseDataParticipantsItem>;

export type SessionsGetSessionParticipantsResponseDataParticipantsList =
  Array<SessionsGetSessionParticipantsResponseDataParticipantsItem>;
export const SessionsGetSessionParticipantsResponseDataParticipantsList =
  /*@__PURE__*/ S.Array(
    SessionsGetSessionParticipantsResponseDataParticipantsItem,
  ) as any as S.Schema<SessionsGetSessionParticipantsResponseDataParticipantsList>;

export interface SessionsGetSessionParticipantsResponseData {
  participants?: SessionsGetSessionParticipantsResponseDataParticipantsList | null;
}
export const SessionsGetSessionParticipantsResponseData =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      participants: S.optional(
        S.NullOr(SessionsGetSessionParticipantsResponseDataParticipantsList),
      ),
    }),
  ).annotate({
    identifier: "SessionsGetSessionParticipantsResponseData",
  }) as any as S.Schema<SessionsGetSessionParticipantsResponseData>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface GetSessionParticipantsSessionResponse {
  data?: SessionsGetSessionParticipantsResponseData | null;
}
export const GetSessionParticipantsSessionResponse = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      data: S.optional(S.NullOr(SessionsGetSessionParticipantsResponseData)),
    }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetSessionParticipantsSessionResponse",
}) as any as S.Schema<GetSessionParticipantsSessionResponse>;

export type SessionsGetSessionsRequestSortBy = "minutesConsumed" | "createdAt";
export const SessionsGetSessionsRequestSortBy = /*@__PURE__*/ S.String;

export type SessionsGetSessionsRequestSortOrder = "ASC" | "DESC";
export const SessionsGetSessionsRequestSortOrder = /*@__PURE__*/ S.String;

export type SessionsGetSessionsRequestStatus = "LIVE" | "ENDED";
export const SessionsGetSessionsRequestStatus = /*@__PURE__*/ S.String;

export interface GetSessionsSessionRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  /** ID of the meeting that sessions should be associated with */
  associatedId?: string;
  /** The end time range for which you want to retrieve the meetings. The time must be specified in ISO format. */
  endTime?: string;
  /** The page number from which you want your page search results to be displayed. */
  pageNo?: number;
  participants?: string;
  /** Number of results per page */
  perPage?: number;
  /** Search string that matches sessions based on meeting title, meeting ID, and session ID */
  search?: string;
  sortBy?: SessionsGetSessionsRequestSortBy | (string & {});
  sortOrder?: SessionsGetSessionsRequestSortOrder | (string & {});
  /** The start time range for which you want to retrieve the meetings. The time must be specified in ISO format. */
  startTime?: string;
  status?: SessionsGetSessionsRequestStatus | (string & {});
}
export const GetSessionsSessionRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    appId: S.String.pipe(T.Label("app_id")),
    associatedId: S.optional(S.String.pipe(T.Query("associated_id"))),
    endTime: S.optional(S.String.pipe(T.Query("end_time"))),
    pageNo: S.optional(S.Number.pipe(T.Query("page_no"))),
    participants: S.optional(S.String.pipe(T.Query())),
    perPage: S.optional(S.Number.pipe(T.Query("per_page"))),
    search: S.optional(S.String.pipe(T.Query())),
    sortBy: S.optional(
      SessionsGetSessionsRequestSortBy.pipe(T.Query("sort_by")),
    ),
    sortOrder: S.optional(
      SessionsGetSessionsRequestSortOrder.pipe(T.Query("sort_order")),
    ),
    startTime: S.optional(S.String.pipe(T.Query("start_time"))),
    status: S.optional(SessionsGetSessionsRequestStatus.pipe(T.Query())),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/realtime/kit/{app_id}/sessions",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetSessionsSessionRequest",
}) as any as S.Schema<GetSessionsSessionRequest>;

export type SessionsGetSessionsResponseDataSessionsItemStatus =
  | "LIVE"
  | "ENDED";
export const SessionsGetSessionsResponseDataSessionsItemStatus =
  /*@__PURE__*/ S.String;

export type SessionsGetSessionsResponseDataSessionsItemType =
  | "meeting"
  | "livestream"
  | "participant";
export const SessionsGetSessionsResponseDataSessionsItemType =
  /*@__PURE__*/ S.String;

export type SessionsGetSessionsResponseDataSessionsItemBreakoutRoomsList =
  Array<unknown>;
export const SessionsGetSessionsResponseDataSessionsItemBreakoutRoomsList =
  /*@__PURE__*/ S.Array(
    S.Unknown,
  ) as any as S.Schema<SessionsGetSessionsResponseDataSessionsItemBreakoutRoomsList>;

export interface SessionsGetSessionsResponseDataSessionsItem {
  /** ID of the session */
  id: string;
  /** ID of the meeting this session is associated with. In the case of V2 meetings, it is always a UUID. In V1 meetings, it is a room name of the form `abcdef-ghijkl` */
  associatedId: string;
  /** timestamp when session created */
  createdAt: string;
  /** number of participants currently in the session */
  liveParticipants: number;
  /** number of maximum participants that were in the session */
  maxConcurrentParticipants: number;
  /** Title of the meeting this session belongs to */
  meetingDisplayName: string;
  /** number of minutes consumed since the session started */
  minutesConsumed: number;
  /** App id that hosted this session */
  organizationId: string;
  /** timestamp when session started */
  startedAt: string;
  /** current status of session */
  status: SessionsGetSessionsResponseDataSessionsItemStatus;
  /** type of session */
  type: SessionsGetSessionsResponseDataSessionsItemType;
  /** timestamp when session was last updated */
  updatedAt: string;
  breakoutRooms?: SessionsGetSessionsResponseDataSessionsItemBreakoutRoomsList | null;
  /** timestamp when session ended */
  endedAt?: string | null;
}
export const SessionsGetSessionsResponseDataSessionsItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      associatedId: S.String.pipe(T.Body("associated_id")),
      createdAt: S.String.pipe(T.Body("created_at")),
      liveParticipants: S.Number.pipe(T.Body("live_participants")),
      maxConcurrentParticipants: S.Number.pipe(
        T.Body("max_concurrent_participants"),
      ),
      meetingDisplayName: S.String.pipe(T.Body("meeting_display_name")),
      minutesConsumed: S.Number.pipe(T.Body("minutes_consumed")),
      organizationId: S.String.pipe(T.Body("organization_id")),
      startedAt: S.String.pipe(T.Body("started_at")),
      status: SessionsGetSessionsResponseDataSessionsItemStatus,
      type: SessionsGetSessionsResponseDataSessionsItemType,
      updatedAt: S.String.pipe(T.Body("updated_at")),
      breakoutRooms: S.optional(
        S.NullOr(
          SessionsGetSessionsResponseDataSessionsItemBreakoutRoomsList,
        ).pipe(T.Body("breakout_rooms")),
      ),
      endedAt: S.optional(S.NullOr(S.String).pipe(T.Body("ended_at"))),
    }),
  ).annotate({
    identifier: "SessionsGetSessionsResponseDataSessionsItem",
  }) as any as S.Schema<SessionsGetSessionsResponseDataSessionsItem>;

export type SessionsGetSessionsResponseDataSessionsList =
  Array<SessionsGetSessionsResponseDataSessionsItem>;
export const SessionsGetSessionsResponseDataSessionsList =
  /*@__PURE__*/ S.Array(
    SessionsGetSessionsResponseDataSessionsItem,
  ) as any as S.Schema<SessionsGetSessionsResponseDataSessionsList>;

export interface SessionsGetSessionsResponseData {
  sessions?: SessionsGetSessionsResponseDataSessionsList | null;
}
export const SessionsGetSessionsResponseData = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    sessions: S.optional(S.NullOr(SessionsGetSessionsResponseDataSessionsList)),
  }),
).annotate({
  identifier: "SessionsGetSessionsResponseData",
}) as any as S.Schema<SessionsGetSessionsResponseData>;

export type SessionsGetSessionsResponsePaging =
  LivestreamsGetAllLivestreamsResponseDataPaging;
export const SessionsGetSessionsResponsePaging =
  LivestreamsGetAllLivestreamsResponseDataPaging;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface GetSessionsSessionResponse {
  data?: SessionsGetSessionsResponseData | null;
  paging?: LivestreamsGetAllLivestreamsResponseDataPaging | null;
}
export const GetSessionsSessionResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    data: S.optional(S.NullOr(SessionsGetSessionsResponseData)),
    paging: S.optional(
      S.NullOr(LivestreamsGetAllLivestreamsResponseDataPaging),
    ),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetSessionsSessionResponse",
}) as any as S.Schema<GetSessionsSessionResponse>;

export interface GetSessionSummarySessionRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  sessionId: string;
}
export const GetSessionSummarySessionRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    appId: S.String.pipe(T.Label("app_id")),
    sessionId: S.String.pipe(T.Label("session_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/realtime/kit/{app_id}/sessions/{session_id}/summary",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetSessionSummarySessionRequest",
}) as any as S.Schema<GetSessionSummarySessionRequest>;

export interface SessionsGetSessionSummaryResponseData {
  sessionId: string;
  /** URL where the summary of transcripts can be downloaded */
  summaryDownloadUrl: string;
  /** Time of Expiry before when you need to download the csv file. */
  summaryDownloadUrlExpiry: string;
}
export const SessionsGetSessionSummaryResponseData = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      sessionId: S.String,
      summaryDownloadUrl: S.String,
      summaryDownloadUrlExpiry: S.String,
    }),
).annotate({
  identifier: "SessionsGetSessionSummaryResponseData",
}) as any as S.Schema<SessionsGetSessionSummaryResponseData>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface GetSessionSummarySessionResponse {
  data?: SessionsGetSessionSummaryResponseData | null;
}
export const GetSessionSummarySessionResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    data: S.optional(S.NullOr(SessionsGetSessionSummaryResponseData)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetSessionSummarySessionResponse",
}) as any as S.Schema<GetSessionSummarySessionResponse>;

export type SessionsGetSessionTranscriptsRequestFormat =
  | "SRT"
  | "VTT"
  | "JSON"
  | "CSV";
export const SessionsGetSessionTranscriptsRequestFormat =
  /*@__PURE__*/ S.String;

export interface GetSessionTranscriptsSessionRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  sessionId: string;
  /** Transcript file format to fetch. */
  format?: SessionsGetSessionTranscriptsRequestFormat | (string & {});
}
export const GetSessionTranscriptsSessionRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    appId: S.String.pipe(T.Label("app_id")),
    sessionId: S.String.pipe(T.Label("session_id")),
    format: S.optional(
      SessionsGetSessionTranscriptsRequestFormat.pipe(T.Query()),
    ),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/realtime/kit/{app_id}/sessions/{session_id}/transcript",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetSessionTranscriptsSessionRequest",
}) as any as S.Schema<GetSessionTranscriptsSessionRequest>;

export interface SessionsGetSessionTranscriptsResponseData {
  sessionId: string;
  /** URL where the transcript can be downloaded */
  transcriptDownloadUrl: string;
  /** Time when the download URL will expire */
  transcriptDownloadUrlExpiry: string;
}
export const SessionsGetSessionTranscriptsResponseData =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      sessionId: S.String,
      transcriptDownloadUrl: S.String.pipe(T.Body("transcript_download_url")),
      transcriptDownloadUrlExpiry: S.String.pipe(
        T.Body("transcript_download_url_expiry"),
      ),
    }),
  ).annotate({
    identifier: "SessionsGetSessionTranscriptsResponseData",
  }) as any as S.Schema<SessionsGetSessionTranscriptsResponseData>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface GetSessionTranscriptsSessionResponse {
  data?: SessionsGetSessionTranscriptsResponseData | null;
}
export const GetSessionTranscriptsSessionResponse = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      data: S.optional(S.NullOr(SessionsGetSessionTranscriptsResponseData)),
    }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetSessionTranscriptsSessionResponse",
}) as any as S.Schema<GetSessionTranscriptsSessionResponse>;

export interface GetWebhookByIdWebhookRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  webhookId: string;
}
export const GetWebhookByIdWebhookRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    appId: S.String.pipe(T.Label("app_id")),
    webhookId: S.String.pipe(T.Label("webhook_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/realtime/kit/{app_id}/webhooks/{webhook_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetWebhookByIdWebhookRequest",
}) as any as S.Schema<GetWebhookByIdWebhookRequest>;

export type WebhooksGetWebhookByIdResponseDataEventsItem =
  | "meeting.started"
  | "meeting.ended"
  | "meeting.participantJoined"
  | "meeting.participantLeft"
  | "meeting.chatSynced"
  | "recording.statusUpdate"
  | "livestreaming.statusUpdate"
  | "meeting.transcript"
  | "meeting.summary";
export const WebhooksGetWebhookByIdResponseDataEventsItem =
  /*@__PURE__*/ S.String;

export type WebhooksGetWebhookByIdResponseDataEventsList =
  Array<WebhooksGetWebhookByIdResponseDataEventsItem>;
export const WebhooksGetWebhookByIdResponseDataEventsList =
  /*@__PURE__*/ S.Array(
    WebhooksGetWebhookByIdResponseDataEventsItem,
  ) as any as S.Schema<WebhooksGetWebhookByIdResponseDataEventsList>;

export interface WebhooksGetWebhookByIdResponseData {
  /** ID of the webhook */
  id: string;
  /** Timestamp when this webhook was created */
  createdAt: string;
  /** Set to true if the webhook is active */
  enabled: boolean;
  /** Events this webhook will send updates for */
  events: WebhooksGetWebhookByIdResponseDataEventsList;
  /** Name of the webhook */
  name: string;
  /** Timestamp when this webhook was updated */
  updatedAt: string;
  /** URL the webhook will send events to */
  url: string;
}
export const WebhooksGetWebhookByIdResponseData = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    createdAt: S.String.pipe(T.Body("created_at")),
    enabled: S.Boolean,
    events: WebhooksGetWebhookByIdResponseDataEventsList,
    name: S.String,
    updatedAt: S.String.pipe(T.Body("updated_at")),
    url: S.String,
  }),
).annotate({
  identifier: "WebhooksGetWebhookByIdResponseData",
}) as any as S.Schema<WebhooksGetWebhookByIdResponseData>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface GetWebhookByIdWebhookResponse {
  data: WebhooksGetWebhookByIdResponseData;
}
export const GetWebhookByIdWebhookResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    data: WebhooksGetWebhookByIdResponseData,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetWebhookByIdWebhookResponse",
}) as any as S.Schema<GetWebhookByIdWebhookResponse>;

export interface GetWebhooksWebhookRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
}
export const GetWebhooksWebhookRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    appId: S.String.pipe(T.Label("app_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/realtime/kit/{app_id}/webhooks",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetWebhooksWebhookRequest",
}) as any as S.Schema<GetWebhooksWebhookRequest>;

export type WebhooksGetWebhooksResponseDataItemEventsItem =
  | "meeting.started"
  | "meeting.ended"
  | "meeting.participantJoined"
  | "meeting.participantLeft"
  | "meeting.chatSynced"
  | "recording.statusUpdate"
  | "livestreaming.statusUpdate"
  | "meeting.transcript"
  | "meeting.summary";
export const WebhooksGetWebhooksResponseDataItemEventsItem =
  /*@__PURE__*/ S.String;

export type WebhooksGetWebhooksResponseDataItemEventsList =
  Array<WebhooksGetWebhooksResponseDataItemEventsItem>;
export const WebhooksGetWebhooksResponseDataItemEventsList =
  /*@__PURE__*/ S.Array(
    WebhooksGetWebhooksResponseDataItemEventsItem,
  ) as any as S.Schema<WebhooksGetWebhooksResponseDataItemEventsList>;

export interface WebhooksGetWebhooksResponseDataItem {
  /** ID of the webhook */
  id: string;
  /** Timestamp when this webhook was created */
  createdAt: string;
  /** Set to true if the webhook is active */
  enabled: boolean;
  /** Events this webhook will send updates for */
  events: WebhooksGetWebhooksResponseDataItemEventsList;
  /** Name of the webhook */
  name: string;
  /** Timestamp when this webhook was updated */
  updatedAt: string;
  /** URL the webhook will send events to */
  url: string;
}
export const WebhooksGetWebhooksResponseDataItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    createdAt: S.String.pipe(T.Body("created_at")),
    enabled: S.Boolean,
    events: WebhooksGetWebhooksResponseDataItemEventsList,
    name: S.String,
    updatedAt: S.String.pipe(T.Body("updated_at")),
    url: S.String,
  }),
).annotate({
  identifier: "WebhooksGetWebhooksResponseDataItem",
}) as any as S.Schema<WebhooksGetWebhooksResponseDataItem>;

export type WebhooksGetWebhooksResponseDataList =
  Array<WebhooksGetWebhooksResponseDataItem>;
export const WebhooksGetWebhooksResponseDataList = /*@__PURE__*/ S.Array(
  WebhooksGetWebhooksResponseDataItem,
) as any as S.Schema<WebhooksGetWebhooksResponseDataList>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface GetWebhooksWebhookResponse {
  data: WebhooksGetWebhooksResponseDataList;
}
export const GetWebhooksWebhookResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    data: WebhooksGetWebhooksResponseDataList,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetWebhooksWebhookResponse",
}) as any as S.Schema<GetWebhooksWebhookResponse>;

export interface KickAllParticipantsActiveSessionRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  meetingId: string;
}
export const KickAllParticipantsActiveSessionRequest = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      accountId: S.String.pipe(T.Label("account_id")),
      appId: S.String.pipe(T.Label("app_id")),
      meetingId: S.String.pipe(T.Label("meeting_id")),
    })
      .pipe(
        T.Http({
          method: "POST",
          uri: "/accounts/{account_id}/realtime/kit/{app_id}/meetings/{meeting_id}/active-session/kick-all",
          code: 200,
        }),
      )
      .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "KickAllParticipantsActiveSessionRequest",
}) as any as S.Schema<KickAllParticipantsActiveSessionRequest>;

export interface ActiveSessionKickAllParticipantsResponseData {
  action?: string | null;
  kickedParticipantsCount?: number | null;
}
export const ActiveSessionKickAllParticipantsResponseData =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      action: S.optional(S.NullOr(S.String)),
      kickedParticipantsCount: S.optional(
        S.NullOr(S.Number).pipe(T.Body("kicked_participants_count")),
      ),
    }),
  ).annotate({
    identifier: "ActiveSessionKickAllParticipantsResponseData",
  }) as any as S.Schema<ActiveSessionKickAllParticipantsResponseData>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface KickAllParticipantsActiveSessionResponse {
  data?: ActiveSessionKickAllParticipantsResponseData | null;
}
export const KickAllParticipantsActiveSessionResponse = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      data: S.optional(S.NullOr(ActiveSessionKickAllParticipantsResponseData)),
    }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "KickAllParticipantsActiveSessionResponse",
}) as any as S.Schema<KickAllParticipantsActiveSessionResponse>;

export type ActiveSessionKickParticipantsRequestCustomParticipantIdsList =
  Array<string>;
export const ActiveSessionKickParticipantsRequestCustomParticipantIdsList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<ActiveSessionKickParticipantsRequestCustomParticipantIdsList>;

export type ActiveSessionKickParticipantsRequestParticipantIdsList =
  Array<string>;
export const ActiveSessionKickParticipantsRequestParticipantIdsList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<ActiveSessionKickParticipantsRequestParticipantIdsList>;

export interface KickParticipantsActiveSessionRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  meetingId: string;
  customParticipantIds: ActiveSessionKickParticipantsRequestCustomParticipantIdsList;
  participantIds: ActiveSessionKickParticipantsRequestParticipantIdsList;
}
export const KickParticipantsActiveSessionRequest = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      accountId: S.String.pipe(T.Label("account_id")),
      appId: S.String.pipe(T.Label("app_id")),
      meetingId: S.String.pipe(T.Label("meeting_id")),
      customParticipantIds:
        ActiveSessionKickParticipantsRequestCustomParticipantIdsList.pipe(
          T.Body("custom_participant_ids"),
        ),
      participantIds:
        ActiveSessionKickParticipantsRequestParticipantIdsList.pipe(
          T.Body("participant_ids"),
        ),
    })
      .pipe(
        T.Http({
          method: "POST",
          uri: "/accounts/{account_id}/realtime/kit/{app_id}/meetings/{meeting_id}/active-session/kick",
          code: 200,
        }),
      )
      .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "KickParticipantsActiveSessionRequest",
}) as any as S.Schema<KickParticipantsActiveSessionRequest>;

export interface ActiveSessionKickParticipantsResponseDataParticipantsItem {
  /** ID of the session participant */
  id: string;
  createdAt: string;
  updatedAt: string;
  /** Email of the session participant. */
  email?: string | null;
  /** Name of the session participant. */
  name?: string | null;
  /** A URL pointing to a picture of the participant. */
  picture?: string | null;
}
export const ActiveSessionKickParticipantsResponseDataParticipantsItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      createdAt: S.String.pipe(T.Body("created_at")),
      updatedAt: S.String.pipe(T.Body("updated_at")),
      email: S.optional(S.NullOr(S.String)),
      name: S.optional(S.NullOr(S.String)),
      picture: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier: "ActiveSessionKickParticipantsResponseDataParticipantsItem",
  }) as any as S.Schema<ActiveSessionKickParticipantsResponseDataParticipantsItem>;

export type ActiveSessionKickParticipantsResponseDataParticipantsList =
  Array<ActiveSessionKickParticipantsResponseDataParticipantsItem>;
export const ActiveSessionKickParticipantsResponseDataParticipantsList =
  /*@__PURE__*/ S.Array(
    ActiveSessionKickParticipantsResponseDataParticipantsItem,
  ) as any as S.Schema<ActiveSessionKickParticipantsResponseDataParticipantsList>;

export interface ActiveSessionKickParticipantsResponseData {
  action?: string | null;
  participants?: ActiveSessionKickParticipantsResponseDataParticipantsList | null;
}
export const ActiveSessionKickParticipantsResponseData =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      action: S.optional(S.NullOr(S.String)),
      participants: S.optional(
        S.NullOr(ActiveSessionKickParticipantsResponseDataParticipantsList),
      ),
    }),
  ).annotate({
    identifier: "ActiveSessionKickParticipantsResponseData",
  }) as any as S.Schema<ActiveSessionKickParticipantsResponseData>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface KickParticipantsActiveSessionResponse {
  data?: ActiveSessionKickParticipantsResponseData | null;
}
export const KickParticipantsActiveSessionResponse = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      data: S.optional(S.NullOr(ActiveSessionKickParticipantsResponseData)),
    }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "KickParticipantsActiveSessionResponse",
}) as any as S.Schema<KickParticipantsActiveSessionResponse>;

export interface LivestreamsGetOrgAnalyticsRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  /** end date in YYYY-MM-DD format */
  endDate?: string;
  /** start date in YYYY-MM-DD format */
  startDate?: string;
}
export const LivestreamsGetOrgAnalyticsRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    appId: S.String.pipe(T.Label("app_id")),
    endDate: S.optional(S.String.pipe(T.Query("end_date"))),
    startDate: S.optional(S.String.pipe(T.Query("start_date"))),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/realtime/kit/{app_id}/analytics/daywise",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "LivestreamsGetOrgAnalyticsRequest",
}) as any as S.Schema<LivestreamsGetOrgAnalyticsRequest>;

export type LivestreamsGetOrgAnalyticsResponseDataRecordingStatsDayStatsItem =
  AnalyticsGetOrgAnalyticsResponseDataRecordingStatsDayStatsItem;
export const LivestreamsGetOrgAnalyticsResponseDataRecordingStatsDayStatsItem =
  AnalyticsGetOrgAnalyticsResponseDataRecordingStatsDayStatsItem;

export type LivestreamsGetOrgAnalyticsResponseDataRecordingStatsDayStatsList =
  Array<AnalyticsGetOrgAnalyticsResponseDataRecordingStatsDayStatsItem>;
export const LivestreamsGetOrgAnalyticsResponseDataRecordingStatsDayStatsList =
  /*@__PURE__*/ S.Array(
    AnalyticsGetOrgAnalyticsResponseDataRecordingStatsDayStatsItem,
  ) as any as S.Schema<LivestreamsGetOrgAnalyticsResponseDataRecordingStatsDayStatsList>;

export interface LivestreamsGetOrgAnalyticsResponseDataRecordingStats {
  /** Day wise recording stats */
  dayStats?: LivestreamsGetOrgAnalyticsResponseDataRecordingStatsDayStatsList | null;
  /** Total number of recordings during the range specified */
  recordingCount?: number | null;
  /** Total recording minutes during the range specified */
  recordingMinutesConsumed?: number | null;
}
export const LivestreamsGetOrgAnalyticsResponseDataRecordingStats =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      dayStats: S.optional(
        S.NullOr(
          LivestreamsGetOrgAnalyticsResponseDataRecordingStatsDayStatsList,
        ).pipe(T.Body("day_stats")),
      ),
      recordingCount: S.optional(
        S.NullOr(S.Number).pipe(T.Body("recording_count")),
      ),
      recordingMinutesConsumed: S.optional(
        S.NullOr(S.Number).pipe(T.Body("recording_minutes_consumed")),
      ),
    }),
  ).annotate({
    identifier: "LivestreamsGetOrgAnalyticsResponseDataRecordingStats",
  }) as any as S.Schema<LivestreamsGetOrgAnalyticsResponseDataRecordingStats>;

export type LivestreamsGetOrgAnalyticsResponseDataSessionStatsDayStatsItem =
  AnalyticsGetOrgAnalyticsResponseDataSessionStatsDayStatsItem;
export const LivestreamsGetOrgAnalyticsResponseDataSessionStatsDayStatsItem =
  AnalyticsGetOrgAnalyticsResponseDataSessionStatsDayStatsItem;

export type LivestreamsGetOrgAnalyticsResponseDataSessionStatsDayStatsList =
  Array<AnalyticsGetOrgAnalyticsResponseDataSessionStatsDayStatsItem>;
export const LivestreamsGetOrgAnalyticsResponseDataSessionStatsDayStatsList =
  /*@__PURE__*/ S.Array(
    AnalyticsGetOrgAnalyticsResponseDataSessionStatsDayStatsItem,
  ) as any as S.Schema<LivestreamsGetOrgAnalyticsResponseDataSessionStatsDayStatsList>;

export interface LivestreamsGetOrgAnalyticsResponseDataSessionStats {
  /** Day wise session stats */
  dayStats?: LivestreamsGetOrgAnalyticsResponseDataSessionStatsDayStatsList | null;
  /** Total number of sessions during the range specified */
  sessionsCount?: number | null;
  /** Total session minutes during the range specified */
  sessionsMinutesConsumed?: number | null;
}
export const LivestreamsGetOrgAnalyticsResponseDataSessionStats =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      dayStats: S.optional(
        S.NullOr(
          LivestreamsGetOrgAnalyticsResponseDataSessionStatsDayStatsList,
        ).pipe(T.Body("day_stats")),
      ),
      sessionsCount: S.optional(
        S.NullOr(S.Number).pipe(T.Body("sessions_count")),
      ),
      sessionsMinutesConsumed: S.optional(
        S.NullOr(S.Number).pipe(T.Body("sessions_minutes_consumed")),
      ),
    }),
  ).annotate({
    identifier: "LivestreamsGetOrgAnalyticsResponseDataSessionStats",
  }) as any as S.Schema<LivestreamsGetOrgAnalyticsResponseDataSessionStats>;

export interface LivestreamsGetOrgAnalyticsResponseData {
  /** Recording statistics of an App during the range specified */
  recordingStats?: LivestreamsGetOrgAnalyticsResponseDataRecordingStats | null;
  /** Session statistics of an App during the range specified */
  sessionStats?: LivestreamsGetOrgAnalyticsResponseDataSessionStats | null;
}
export const LivestreamsGetOrgAnalyticsResponseData = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      recordingStats: S.optional(
        S.NullOr(LivestreamsGetOrgAnalyticsResponseDataRecordingStats).pipe(
          T.Body("recording_stats"),
        ),
      ),
      sessionStats: S.optional(
        S.NullOr(LivestreamsGetOrgAnalyticsResponseDataSessionStats).pipe(
          T.Body("session_stats"),
        ),
      ),
    }),
).annotate({
  identifier: "LivestreamsGetOrgAnalyticsResponseData",
}) as any as S.Schema<LivestreamsGetOrgAnalyticsResponseData>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface LivestreamsGetOrgAnalyticsResponse {
  data?: LivestreamsGetOrgAnalyticsResponseData | null;
}
export const LivestreamsGetOrgAnalyticsResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    data: S.optional(S.NullOr(LivestreamsGetOrgAnalyticsResponseData)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "LivestreamsGetOrgAnalyticsResponse",
}) as any as S.Schema<LivestreamsGetOrgAnalyticsResponse>;

export type PresetsUpdateRequestConfigLivestreamViewerQualitiesList =
  Array<number>;
export const PresetsUpdateRequestConfigLivestreamViewerQualitiesList =
  /*@__PURE__*/ S.Array(
    S.Number,
  ) as any as S.Schema<PresetsUpdateRequestConfigLivestreamViewerQualitiesList>;

export interface PresetsUpdateRequestConfigMaxVideoStreams {
  /** Maximum number of video streams visible on desktop devices */
  desktop?: number;
  /** Maximum number of streams visible on mobile devices */
  mobile?: number;
}
export const PresetsUpdateRequestConfigMaxVideoStreams =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      desktop: S.optional(S.Number),
      mobile: S.optional(S.Number),
    }),
  ).annotate({
    identifier: "PresetsUpdateRequestConfigMaxVideoStreams",
  }) as any as S.Schema<PresetsUpdateRequestConfigMaxVideoStreams>;

export type PresetsUpdateRequestConfigMediaAudio =
  PresetsCreateRequestConfigMediaAudio;
export const PresetsUpdateRequestConfigMediaAudio =
  PresetsCreateRequestConfigMediaAudio;

export type PresetsUpdateRequestConfigMediaScreenshareQuality =
  | "hd"
  | "vga"
  | "qvga"
  | "fhd"
  | "uhd";
export const PresetsUpdateRequestConfigMediaScreenshareQuality =
  /*@__PURE__*/ S.String;

export interface PresetsUpdateRequestConfigMediaScreenshare {
  /** Frame rate of screen share */
  frameRate?: number;
  /** Quality of screen share */
  quality?: PresetsUpdateRequestConfigMediaScreenshareQuality | (string & {});
}
export const PresetsUpdateRequestConfigMediaScreenshare =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      frameRate: S.optional(S.Number.pipe(T.Body("frame_rate"))),
      quality: S.optional(PresetsUpdateRequestConfigMediaScreenshareQuality),
    }),
  ).annotate({
    identifier: "PresetsUpdateRequestConfigMediaScreenshare",
  }) as any as S.Schema<PresetsUpdateRequestConfigMediaScreenshare>;

export type PresetsUpdateRequestConfigMediaVideoQuality =
  | "hd"
  | "vga"
  | "qvga"
  | "fhd"
  | "uhd";
export const PresetsUpdateRequestConfigMediaVideoQuality =
  /*@__PURE__*/ S.String;

export interface PresetsUpdateRequestConfigMediaVideo {
  /** Frame rate of participants' video */
  frameRate?: number;
  /** Video quality of participants */
  quality?: PresetsUpdateRequestConfigMediaVideoQuality | (string & {});
  /** Enable simulcast for participant videos. */
  simulcast?: boolean;
}
export const PresetsUpdateRequestConfigMediaVideo = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      frameRate: S.optional(S.Number.pipe(T.Body("frame_rate"))),
      quality: S.optional(PresetsUpdateRequestConfigMediaVideoQuality),
      simulcast: S.optional(S.Boolean),
    }),
).annotate({
  identifier: "PresetsUpdateRequestConfigMediaVideo",
}) as any as S.Schema<PresetsUpdateRequestConfigMediaVideo>;

export interface PresetsUpdateRequestConfigMedia {
  /** Control options for Audio quality. */
  audio?: PresetsCreateRequestConfigMediaAudio;
  /** Configuration options for participant screen shares */
  screenshare?: PresetsUpdateRequestConfigMediaScreenshare;
  /** Configuration options for participant videos */
  video?: PresetsUpdateRequestConfigMediaVideo;
}
export const PresetsUpdateRequestConfigMedia = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    audio: S.optional(PresetsCreateRequestConfigMediaAudio),
    screenshare: S.optional(PresetsUpdateRequestConfigMediaScreenshare),
    video: S.optional(PresetsUpdateRequestConfigMediaVideo),
  }),
).annotate({
  identifier: "PresetsUpdateRequestConfigMedia",
}) as any as S.Schema<PresetsUpdateRequestConfigMedia>;

export type PresetsUpdateRequestConfigViewType =
  | "GROUP_CALL"
  | "WEBINAR"
  | "AUDIO_ROOM"
  | "LIVESTREAM";
export const PresetsUpdateRequestConfigViewType = /*@__PURE__*/ S.String;

export interface PresetsUpdateRequestConfig {
  /** Livestream viewer quality levels. */
  livestreamViewerQualities?: PresetsUpdateRequestConfigLivestreamViewerQualitiesList;
  /** Maximum number of screen shares that can be active at a given time */
  maxScreenshareCount?: number;
  /** Maximum number of streams that are visible on a device */
  maxVideoStreams?: PresetsUpdateRequestConfigMaxVideoStreams;
  /** Media configuration options. eg: Video quality */
  media?: PresetsUpdateRequestConfigMedia;
  /** Type of the meeting */
  viewType?: PresetsUpdateRequestConfigViewType | (string & {});
}
export const PresetsUpdateRequestConfig = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    livestreamViewerQualities: S.optional(
      PresetsUpdateRequestConfigLivestreamViewerQualitiesList.pipe(
        T.Body("livestream_viewer_qualities"),
      ),
    ),
    maxScreenshareCount: S.optional(
      S.Number.pipe(T.Body("max_screenshare_count")),
    ),
    maxVideoStreams: S.optional(
      PresetsUpdateRequestConfigMaxVideoStreams.pipe(
        T.Body("max_video_streams"),
      ),
    ),
    media: S.optional(PresetsUpdateRequestConfigMedia),
    viewType: S.optional(
      PresetsUpdateRequestConfigViewType.pipe(T.Body("view_type")),
    ),
  }),
).annotate({
  identifier: "PresetsUpdateRequestConfig",
}) as any as S.Schema<PresetsUpdateRequestConfig>;

export interface PresetsUpdateRequestPermissionsChatPrivate {
  canReceive?: boolean;
  canSend?: boolean;
  files?: boolean;
  text?: boolean;
}
export const PresetsUpdateRequestPermissionsChatPrivate =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      canReceive: S.optional(S.Boolean.pipe(T.Body("can_receive"))),
      canSend: S.optional(S.Boolean.pipe(T.Body("can_send"))),
      files: S.optional(S.Boolean),
      text: S.optional(S.Boolean),
    }),
  ).annotate({
    identifier: "PresetsUpdateRequestPermissionsChatPrivate",
  }) as any as S.Schema<PresetsUpdateRequestPermissionsChatPrivate>;

export interface PresetsUpdateRequestPermissionsChatPublic {
  /** Can send messages in general */
  canSend?: boolean;
  /** Can send file messages */
  files?: boolean;
  /** Can send text messages */
  text?: boolean;
}
export const PresetsUpdateRequestPermissionsChatPublic =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      canSend: S.optional(S.Boolean.pipe(T.Body("can_send"))),
      files: S.optional(S.Boolean),
      text: S.optional(S.Boolean),
    }),
  ).annotate({
    identifier: "PresetsUpdateRequestPermissionsChatPublic",
  }) as any as S.Schema<PresetsUpdateRequestPermissionsChatPublic>;

export interface PresetsUpdateRequestPermissionsChat {
  private?: PresetsUpdateRequestPermissionsChatPrivate;
  public?: PresetsUpdateRequestPermissionsChatPublic;
}
export const PresetsUpdateRequestPermissionsChat = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    private: S.optional(PresetsUpdateRequestPermissionsChatPrivate),
    public: S.optional(PresetsUpdateRequestPermissionsChatPublic),
  }),
).annotate({
  identifier: "PresetsUpdateRequestPermissionsChat",
}) as any as S.Schema<PresetsUpdateRequestPermissionsChat>;

export interface PresetsUpdateRequestPermissionsConnectedMeetings {
  canAlterConnectedMeetings?: boolean;
  canSwitchConnectedMeetings?: boolean;
  canSwitchToParentMeeting?: boolean;
}
export const PresetsUpdateRequestPermissionsConnectedMeetings =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      canAlterConnectedMeetings: S.optional(
        S.Boolean.pipe(T.Body("can_alter_connected_meetings")),
      ),
      canSwitchConnectedMeetings: S.optional(
        S.Boolean.pipe(T.Body("can_switch_connected_meetings")),
      ),
      canSwitchToParentMeeting: S.optional(
        S.Boolean.pipe(T.Body("can_switch_to_parent_meeting")),
      ),
    }),
  ).annotate({
    identifier: "PresetsUpdateRequestPermissionsConnectedMeetings",
  }) as any as S.Schema<PresetsUpdateRequestPermissionsConnectedMeetings>;

export type PresetsUpdateRequestPermissionsMediaAudioCanProduce =
  | "ALLOWED"
  | "NOT_ALLOWED"
  | "CAN_REQUEST";
export const PresetsUpdateRequestPermissionsMediaAudioCanProduce =
  /*@__PURE__*/ S.String;

export interface PresetsUpdateRequestPermissionsMediaAudio {
  /** Can produce audio */
  canProduce?:
    | PresetsUpdateRequestPermissionsMediaAudioCanProduce
    | (string & {});
}
export const PresetsUpdateRequestPermissionsMediaAudio =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      canProduce: S.optional(
        PresetsUpdateRequestPermissionsMediaAudioCanProduce.pipe(
          T.Body("can_produce"),
        ),
      ),
    }),
  ).annotate({
    identifier: "PresetsUpdateRequestPermissionsMediaAudio",
  }) as any as S.Schema<PresetsUpdateRequestPermissionsMediaAudio>;

export type PresetsUpdateRequestPermissionsMediaScreenshareCanProduce =
  | "ALLOWED"
  | "NOT_ALLOWED"
  | "CAN_REQUEST";
export const PresetsUpdateRequestPermissionsMediaScreenshareCanProduce =
  /*@__PURE__*/ S.String;

export interface PresetsUpdateRequestPermissionsMediaScreenshare {
  /** Can produce screen share video */
  canProduce?:
    | PresetsUpdateRequestPermissionsMediaScreenshareCanProduce
    | (string & {});
}
export const PresetsUpdateRequestPermissionsMediaScreenshare =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      canProduce: S.optional(
        PresetsUpdateRequestPermissionsMediaScreenshareCanProduce.pipe(
          T.Body("can_produce"),
        ),
      ),
    }),
  ).annotate({
    identifier: "PresetsUpdateRequestPermissionsMediaScreenshare",
  }) as any as S.Schema<PresetsUpdateRequestPermissionsMediaScreenshare>;

export type PresetsUpdateRequestPermissionsMediaVideoCanProduce =
  | "ALLOWED"
  | "NOT_ALLOWED"
  | "CAN_REQUEST";
export const PresetsUpdateRequestPermissionsMediaVideoCanProduce =
  /*@__PURE__*/ S.String;

export interface PresetsUpdateRequestPermissionsMediaVideo {
  /** Can produce video */
  canProduce?:
    | PresetsUpdateRequestPermissionsMediaVideoCanProduce
    | (string & {});
}
export const PresetsUpdateRequestPermissionsMediaVideo =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      canProduce: S.optional(
        PresetsUpdateRequestPermissionsMediaVideoCanProduce.pipe(
          T.Body("can_produce"),
        ),
      ),
    }),
  ).annotate({
    identifier: "PresetsUpdateRequestPermissionsMediaVideo",
  }) as any as S.Schema<PresetsUpdateRequestPermissionsMediaVideo>;

export interface PresetsUpdateRequestPermissionsMedia {
  /** Audio permissions */
  audio?: PresetsUpdateRequestPermissionsMediaAudio;
  /** Screenshare permissions */
  screenshare?: PresetsUpdateRequestPermissionsMediaScreenshare;
  /** Video permissions */
  video?: PresetsUpdateRequestPermissionsMediaVideo;
}
export const PresetsUpdateRequestPermissionsMedia = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      audio: S.optional(PresetsUpdateRequestPermissionsMediaAudio),
      screenshare: S.optional(PresetsUpdateRequestPermissionsMediaScreenshare),
      video: S.optional(PresetsUpdateRequestPermissionsMediaVideo),
    }),
).annotate({
  identifier: "PresetsUpdateRequestPermissionsMedia",
}) as any as S.Schema<PresetsUpdateRequestPermissionsMedia>;

export interface PresetsUpdateRequestPermissionsPlugins {
  /** Can close plugins that are already open */
  canClose?: boolean;
  /** Can edit plugin config */
  canEditConfig?: boolean;
  /** Can start plugins */
  canStart?: boolean;
  /** Plugin configuration keyed by plugin UUID. */
  config?: unknown;
}
export const PresetsUpdateRequestPermissionsPlugins = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      canClose: S.optional(S.Boolean.pipe(T.Body("can_close"))),
      canEditConfig: S.optional(S.Boolean.pipe(T.Body("can_edit_config"))),
      canStart: S.optional(S.Boolean.pipe(T.Body("can_start"))),
      config: S.optional(S.Unknown),
    }),
).annotate({
  identifier: "PresetsUpdateRequestPermissionsPlugins",
}) as any as S.Schema<PresetsUpdateRequestPermissionsPlugins>;

export interface PresetsUpdateRequestPermissionsPolls {
  /** Can create polls */
  canCreate?: boolean;
  /** Can view polls */
  canView?: boolean;
  /** Can vote on polls */
  canVote?: boolean;
}
export const PresetsUpdateRequestPermissionsPolls = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      canCreate: S.optional(S.Boolean.pipe(T.Body("can_create"))),
      canView: S.optional(S.Boolean.pipe(T.Body("can_view"))),
      canVote: S.optional(S.Boolean.pipe(T.Body("can_vote"))),
    }),
).annotate({
  identifier: "PresetsUpdateRequestPermissionsPolls",
}) as any as S.Schema<PresetsUpdateRequestPermissionsPolls>;

export type PresetsUpdateRequestPermissionsRecorderType =
  | "RECORDER"
  | "LIVESTREAMER"
  | "NONE";
export const PresetsUpdateRequestPermissionsRecorderType =
  /*@__PURE__*/ S.String;

export type PresetsUpdateRequestPermissionsStageAccess =
  | "ALLOWED"
  | "NOT_ALLOWED"
  | "CAN_REQUEST";
export const PresetsUpdateRequestPermissionsStageAccess =
  /*@__PURE__*/ S.String;

export type PresetsUpdateRequestPermissionsWaitingRoomType =
  | "SKIP"
  | "ON_PRIVILEGED_USER_ENTRY"
  | "SKIP_ON_ACCEPT";
export const PresetsUpdateRequestPermissionsWaitingRoomType =
  /*@__PURE__*/ S.String;

export interface PresetsUpdateRequestPermissions {
  acceptStageRequests?: boolean;
  /** Whether this participant can accept waiting requests */
  acceptWaitingRequests?: boolean;
  canAcceptProductionRequests?: boolean;
  canChangeParticipantPermissions?: boolean;
  canEditDisplayName?: boolean;
  canLivestream?: boolean;
  canRecord?: boolean;
  canSpotlight?: boolean;
  chat?: PresetsUpdateRequestPermissionsChat;
  connectedMeetings?: PresetsUpdateRequestPermissionsConnectedMeetings;
  disableParticipantAudio?: boolean;
  disableParticipantScreensharing?: boolean;
  disableParticipantVideo?: boolean;
  /** Whether this participant is visible to others or not */
  hiddenParticipant?: boolean;
  isRecorder?: boolean;
  kickParticipant?: boolean;
  /** Media permissions */
  media?: PresetsUpdateRequestPermissionsMedia;
  pinParticipant?: boolean;
  /** Plugin permissions */
  plugins?: PresetsUpdateRequestPermissionsPlugins;
  /** Poll permissions */
  polls?: PresetsUpdateRequestPermissionsPolls;
  /** Type of the recording peer */
  recorderType?: PresetsUpdateRequestPermissionsRecorderType | (string & {});
  showParticipantList?: boolean;
  stageAccess?: PresetsUpdateRequestPermissionsStageAccess | (string & {});
  stageEnabled?: boolean;
  transcriptionEnabled?: boolean;
  /** Waiting room type */
  waitingRoomType?:
    | PresetsUpdateRequestPermissionsWaitingRoomType
    | (string & {});
}
export const PresetsUpdateRequestPermissions = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    acceptStageRequests: S.optional(
      S.Boolean.pipe(T.Body("accept_stage_requests")),
    ),
    acceptWaitingRequests: S.optional(
      S.Boolean.pipe(T.Body("accept_waiting_requests")),
    ),
    canAcceptProductionRequests: S.optional(
      S.Boolean.pipe(T.Body("can_accept_production_requests")),
    ),
    canChangeParticipantPermissions: S.optional(
      S.Boolean.pipe(T.Body("can_change_participant_permissions")),
    ),
    canEditDisplayName: S.optional(
      S.Boolean.pipe(T.Body("can_edit_display_name")),
    ),
    canLivestream: S.optional(S.Boolean.pipe(T.Body("can_livestream"))),
    canRecord: S.optional(S.Boolean.pipe(T.Body("can_record"))),
    canSpotlight: S.optional(S.Boolean.pipe(T.Body("can_spotlight"))),
    chat: S.optional(PresetsUpdateRequestPermissionsChat),
    connectedMeetings: S.optional(
      PresetsUpdateRequestPermissionsConnectedMeetings.pipe(
        T.Body("connected_meetings"),
      ),
    ),
    disableParticipantAudio: S.optional(
      S.Boolean.pipe(T.Body("disable_participant_audio")),
    ),
    disableParticipantScreensharing: S.optional(
      S.Boolean.pipe(T.Body("disable_participant_screensharing")),
    ),
    disableParticipantVideo: S.optional(
      S.Boolean.pipe(T.Body("disable_participant_video")),
    ),
    hiddenParticipant: S.optional(S.Boolean.pipe(T.Body("hidden_participant"))),
    isRecorder: S.optional(S.Boolean.pipe(T.Body("is_recorder"))),
    kickParticipant: S.optional(S.Boolean.pipe(T.Body("kick_participant"))),
    media: S.optional(PresetsUpdateRequestPermissionsMedia),
    pinParticipant: S.optional(S.Boolean.pipe(T.Body("pin_participant"))),
    plugins: S.optional(PresetsUpdateRequestPermissionsPlugins),
    polls: S.optional(PresetsUpdateRequestPermissionsPolls),
    recorderType: S.optional(
      PresetsUpdateRequestPermissionsRecorderType.pipe(T.Body("recorder_type")),
    ),
    showParticipantList: S.optional(
      S.Boolean.pipe(T.Body("show_participant_list")),
    ),
    stageAccess: S.optional(
      PresetsUpdateRequestPermissionsStageAccess.pipe(T.Body("stage_access")),
    ),
    stageEnabled: S.optional(S.Boolean.pipe(T.Body("stage_enabled"))),
    transcriptionEnabled: S.optional(
      S.Boolean.pipe(T.Body("transcription_enabled")),
    ),
    waitingRoomType: S.optional(
      PresetsUpdateRequestPermissionsWaitingRoomType.pipe(
        T.Body("waiting_room_type"),
      ),
    ),
  }),
).annotate({
  identifier: "PresetsUpdateRequestPermissions",
}) as any as S.Schema<PresetsUpdateRequestPermissions>;

export type PresetsUpdateRequestUiDesignTokensBorderRadius =
  | "sharp"
  | "rounded"
  | "extra-rounded"
  | "circular";
export const PresetsUpdateRequestUiDesignTokensBorderRadius =
  /*@__PURE__*/ S.String;

export type PresetsUpdateRequestUiDesignTokensBorderWidth =
  | "none"
  | "thin"
  | "fat";
export const PresetsUpdateRequestUiDesignTokensBorderWidth =
  /*@__PURE__*/ S.String;

export interface PresetsUpdateRequestUiDesignTokensColorsBackground {
  "1000"?: string;
  "600"?: string;
  "700"?: string;
  "800"?: string;
  "900"?: string;
}
export const PresetsUpdateRequestUiDesignTokensColorsBackground =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      "1000": S.optional(S.String),
      "600": S.optional(S.String),
      "700": S.optional(S.String),
      "800": S.optional(S.String),
      "900": S.optional(S.String),
    }),
  ).annotate({
    identifier: "PresetsUpdateRequestUiDesignTokensColorsBackground",
  }) as any as S.Schema<PresetsUpdateRequestUiDesignTokensColorsBackground>;

export interface PresetsUpdateRequestUiDesignTokensColorsBrand {
  "300"?: string;
  "400"?: string;
  "500"?: string;
  "600"?: string;
  "700"?: string;
}
export const PresetsUpdateRequestUiDesignTokensColorsBrand =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      "300": S.optional(S.String),
      "400": S.optional(S.String),
      "500": S.optional(S.String),
      "600": S.optional(S.String),
      "700": S.optional(S.String),
    }),
  ).annotate({
    identifier: "PresetsUpdateRequestUiDesignTokensColorsBrand",
  }) as any as S.Schema<PresetsUpdateRequestUiDesignTokensColorsBrand>;

export interface PresetsUpdateRequestUiDesignTokensColors {
  background?: PresetsUpdateRequestUiDesignTokensColorsBackground;
  brand?: PresetsUpdateRequestUiDesignTokensColorsBrand;
  danger?: string;
  success?: string;
  text?: string;
  textOnBrand?: string;
  videoBg?: string;
  warning?: string;
}
export const PresetsUpdateRequestUiDesignTokensColors = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      background: S.optional(
        PresetsUpdateRequestUiDesignTokensColorsBackground,
      ),
      brand: S.optional(PresetsUpdateRequestUiDesignTokensColorsBrand),
      danger: S.optional(S.String),
      success: S.optional(S.String),
      text: S.optional(S.String),
      textOnBrand: S.optional(S.String.pipe(T.Body("text_on_brand"))),
      videoBg: S.optional(S.String.pipe(T.Body("video_bg"))),
      warning: S.optional(S.String),
    }),
).annotate({
  identifier: "PresetsUpdateRequestUiDesignTokensColors",
}) as any as S.Schema<PresetsUpdateRequestUiDesignTokensColors>;

export type PresetsUpdateRequestUiDesignTokensTheme =
  | "darkest"
  | "dark"
  | "light";
export const PresetsUpdateRequestUiDesignTokensTheme = /*@__PURE__*/ S.String;

export interface PresetsUpdateRequestUiDesignTokens {
  borderRadius?: PresetsUpdateRequestUiDesignTokensBorderRadius | (string & {});
  borderWidth?: PresetsUpdateRequestUiDesignTokensBorderWidth | (string & {});
  colors?: PresetsUpdateRequestUiDesignTokensColors;
  fontFamily?: string;
  googleFont?: string;
  logo?: string;
  spacingBase?: number;
  theme?: PresetsUpdateRequestUiDesignTokensTheme | (string & {});
}
export const PresetsUpdateRequestUiDesignTokens = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    borderRadius: S.optional(
      PresetsUpdateRequestUiDesignTokensBorderRadius.pipe(
        T.Body("border_radius"),
      ),
    ),
    borderWidth: S.optional(
      PresetsUpdateRequestUiDesignTokensBorderWidth.pipe(
        T.Body("border_width"),
      ),
    ),
    colors: S.optional(PresetsUpdateRequestUiDesignTokensColors),
    fontFamily: S.optional(S.String.pipe(T.Body("font_family"))),
    googleFont: S.optional(S.String.pipe(T.Body("google_font"))),
    logo: S.optional(S.String),
    spacingBase: S.optional(S.Number.pipe(T.Body("spacing_base"))),
    theme: S.optional(PresetsUpdateRequestUiDesignTokensTheme),
  }),
).annotate({
  identifier: "PresetsUpdateRequestUiDesignTokens",
}) as any as S.Schema<PresetsUpdateRequestUiDesignTokens>;

export interface PresetsUpdateRequestUi {
  designTokens?: PresetsUpdateRequestUiDesignTokens;
}
export const PresetsUpdateRequestUi = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    designTokens: S.optional(
      PresetsUpdateRequestUiDesignTokens.pipe(T.Body("design_tokens")),
    ),
  }),
).annotate({
  identifier: "PresetsUpdateRequestUi",
}) as any as S.Schema<PresetsUpdateRequestUi>;

export interface PatchPresetRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  presetId: string;
  config?: PresetsUpdateRequestConfig;
  /** Name of the preset */
  name?: string;
  permissions?: PresetsUpdateRequestPermissions;
  ui?: PresetsUpdateRequestUi;
}
export const PatchPresetRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    appId: S.String.pipe(T.Label("app_id")),
    presetId: S.String.pipe(T.Label("preset_id")),
    config: S.optional(PresetsUpdateRequestConfig),
    name: S.optional(S.String),
    permissions: S.optional(PresetsUpdateRequestPermissions),
    ui: S.optional(PresetsUpdateRequestUi),
  })
    .pipe(
      T.Http({
        method: "PATCH",
        uri: "/accounts/{account_id}/realtime/kit/{app_id}/presets/{preset_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PatchPresetRequest",
}) as any as S.Schema<PatchPresetRequest>;

export type PresetsUpdateResponseDataConfigMaxVideoStreams =
  PresetsCreateRequestConfigMaxVideoStreams;
export const PresetsUpdateResponseDataConfigMaxVideoStreams =
  PresetsCreateRequestConfigMaxVideoStreams;

export type PresetsUpdateResponseDataConfigMediaScreenshareQuality =
  | "hd"
  | "vga"
  | "qvga"
  | "fhd"
  | "uhd";
export const PresetsUpdateResponseDataConfigMediaScreenshareQuality =
  /*@__PURE__*/ S.String;

export interface PresetsUpdateResponseDataConfigMediaScreenshare {
  /** Frame rate of screen share */
  frameRate: number;
  /** Quality of screen share */
  quality: PresetsUpdateResponseDataConfigMediaScreenshareQuality;
}
export const PresetsUpdateResponseDataConfigMediaScreenshare =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      frameRate: S.Number.pipe(T.Body("frame_rate")),
      quality: PresetsUpdateResponseDataConfigMediaScreenshareQuality,
    }),
  ).annotate({
    identifier: "PresetsUpdateResponseDataConfigMediaScreenshare",
  }) as any as S.Schema<PresetsUpdateResponseDataConfigMediaScreenshare>;

export type PresetsUpdateResponseDataConfigMediaVideoQuality =
  | "hd"
  | "vga"
  | "qvga"
  | "fhd"
  | "uhd";
export const PresetsUpdateResponseDataConfigMediaVideoQuality =
  /*@__PURE__*/ S.String;

export interface PresetsUpdateResponseDataConfigMediaVideo {
  /** Frame rate of participants' video */
  frameRate: number;
  /** Video quality of participants */
  quality: PresetsUpdateResponseDataConfigMediaVideoQuality;
  /** Enable simulcast for participant videos. */
  simulcast?: boolean | null;
}
export const PresetsUpdateResponseDataConfigMediaVideo =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      frameRate: S.Number.pipe(T.Body("frame_rate")),
      quality: PresetsUpdateResponseDataConfigMediaVideoQuality,
      simulcast: S.optional(S.NullOr(S.Boolean)),
    }),
  ).annotate({
    identifier: "PresetsUpdateResponseDataConfigMediaVideo",
  }) as any as S.Schema<PresetsUpdateResponseDataConfigMediaVideo>;

export type PresetsUpdateResponseDataConfigMediaAudio =
  PresetsCreateResponseDataConfigMediaAudio;
export const PresetsUpdateResponseDataConfigMediaAudio =
  PresetsCreateResponseDataConfigMediaAudio;

export interface PresetsUpdateResponseDataConfigMedia {
  /** Configuration options for participant screen shares */
  screenshare: PresetsUpdateResponseDataConfigMediaScreenshare;
  /** Configuration options for participant videos */
  video: PresetsUpdateResponseDataConfigMediaVideo;
  /** Control options for Audio quality. */
  audio?: PresetsCreateResponseDataConfigMediaAudio | null;
}
export const PresetsUpdateResponseDataConfigMedia = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      screenshare: PresetsUpdateResponseDataConfigMediaScreenshare,
      video: PresetsUpdateResponseDataConfigMediaVideo,
      audio: S.optional(S.NullOr(PresetsCreateResponseDataConfigMediaAudio)),
    }),
).annotate({
  identifier: "PresetsUpdateResponseDataConfigMedia",
}) as any as S.Schema<PresetsUpdateResponseDataConfigMedia>;

export type PresetsUpdateResponseDataConfigViewType =
  | "GROUP_CALL"
  | "WEBINAR"
  | "AUDIO_ROOM"
  | "LIVESTREAM";
export const PresetsUpdateResponseDataConfigViewType = /*@__PURE__*/ S.String;

export type PresetsUpdateResponseDataConfigLivestreamViewerQualitiesList =
  Array<number>;
export const PresetsUpdateResponseDataConfigLivestreamViewerQualitiesList =
  /*@__PURE__*/ S.Array(
    S.Number,
  ) as any as S.Schema<PresetsUpdateResponseDataConfigLivestreamViewerQualitiesList>;

export interface PresetsUpdateResponseDataConfig {
  /** Maximum number of screen shares that can be active at a given time */
  maxScreenshareCount: number;
  /** Maximum number of streams that are visible on a device */
  maxVideoStreams: PresetsCreateRequestConfigMaxVideoStreams;
  /** Media configuration options. eg: Video quality */
  media: PresetsUpdateResponseDataConfigMedia;
  /** Type of the meeting */
  viewType: PresetsUpdateResponseDataConfigViewType;
  /** Livestream viewer quality levels. */
  livestreamViewerQualities?: PresetsUpdateResponseDataConfigLivestreamViewerQualitiesList | null;
}
export const PresetsUpdateResponseDataConfig = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    maxScreenshareCount: S.Number.pipe(T.Body("max_screenshare_count")),
    maxVideoStreams: PresetsCreateRequestConfigMaxVideoStreams.pipe(
      T.Body("max_video_streams"),
    ),
    media: PresetsUpdateResponseDataConfigMedia,
    viewType: PresetsUpdateResponseDataConfigViewType.pipe(T.Body("view_type")),
    livestreamViewerQualities: S.optional(
      S.NullOr(
        PresetsUpdateResponseDataConfigLivestreamViewerQualitiesList,
      ).pipe(T.Body("livestream_viewer_qualities")),
    ),
  }),
).annotate({
  identifier: "PresetsUpdateResponseDataConfig",
}) as any as S.Schema<PresetsUpdateResponseDataConfig>;

export type PresetsUpdateResponseDataPermissionsChatPrivate =
  PresetsCreateRequestPermissionsChatPrivate;
export const PresetsUpdateResponseDataPermissionsChatPrivate =
  PresetsCreateRequestPermissionsChatPrivate;

export type PresetsUpdateResponseDataPermissionsChatPublic =
  PresetsCreateRequestPermissionsChatPublic;
export const PresetsUpdateResponseDataPermissionsChatPublic =
  PresetsCreateRequestPermissionsChatPublic;

export type PresetsUpdateResponseDataPermissionsChat =
  PresetsCreateRequestPermissionsChat;
export const PresetsUpdateResponseDataPermissionsChat =
  PresetsCreateRequestPermissionsChat;

export type PresetsUpdateResponseDataPermissionsConnectedMeetings =
  PresetsCreateRequestPermissionsConnectedMeetings;
export const PresetsUpdateResponseDataPermissionsConnectedMeetings =
  PresetsCreateRequestPermissionsConnectedMeetings;

export type PresetsUpdateResponseDataPermissionsMediaAudioCanProduce =
  | "ALLOWED"
  | "NOT_ALLOWED"
  | "CAN_REQUEST";
export const PresetsUpdateResponseDataPermissionsMediaAudioCanProduce =
  /*@__PURE__*/ S.String;

export interface PresetsUpdateResponseDataPermissionsMediaAudio {
  /** Can produce audio */
  canProduce: PresetsUpdateResponseDataPermissionsMediaAudioCanProduce;
}
export const PresetsUpdateResponseDataPermissionsMediaAudio =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      canProduce: PresetsUpdateResponseDataPermissionsMediaAudioCanProduce.pipe(
        T.Body("can_produce"),
      ),
    }),
  ).annotate({
    identifier: "PresetsUpdateResponseDataPermissionsMediaAudio",
  }) as any as S.Schema<PresetsUpdateResponseDataPermissionsMediaAudio>;

export type PresetsUpdateResponseDataPermissionsMediaScreenshareCanProduce =
  | "ALLOWED"
  | "NOT_ALLOWED"
  | "CAN_REQUEST";
export const PresetsUpdateResponseDataPermissionsMediaScreenshareCanProduce =
  /*@__PURE__*/ S.String;

export interface PresetsUpdateResponseDataPermissionsMediaScreenshare {
  /** Can produce screen share video */
  canProduce: PresetsUpdateResponseDataPermissionsMediaScreenshareCanProduce;
}
export const PresetsUpdateResponseDataPermissionsMediaScreenshare =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      canProduce:
        PresetsUpdateResponseDataPermissionsMediaScreenshareCanProduce.pipe(
          T.Body("can_produce"),
        ),
    }),
  ).annotate({
    identifier: "PresetsUpdateResponseDataPermissionsMediaScreenshare",
  }) as any as S.Schema<PresetsUpdateResponseDataPermissionsMediaScreenshare>;

export type PresetsUpdateResponseDataPermissionsMediaVideoCanProduce =
  | "ALLOWED"
  | "NOT_ALLOWED"
  | "CAN_REQUEST";
export const PresetsUpdateResponseDataPermissionsMediaVideoCanProduce =
  /*@__PURE__*/ S.String;

export interface PresetsUpdateResponseDataPermissionsMediaVideo {
  /** Can produce video */
  canProduce: PresetsUpdateResponseDataPermissionsMediaVideoCanProduce;
}
export const PresetsUpdateResponseDataPermissionsMediaVideo =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      canProduce: PresetsUpdateResponseDataPermissionsMediaVideoCanProduce.pipe(
        T.Body("can_produce"),
      ),
    }),
  ).annotate({
    identifier: "PresetsUpdateResponseDataPermissionsMediaVideo",
  }) as any as S.Schema<PresetsUpdateResponseDataPermissionsMediaVideo>;

export interface PresetsUpdateResponseDataPermissionsMedia {
  /** Audio permissions */
  audio: PresetsUpdateResponseDataPermissionsMediaAudio;
  /** Screenshare permissions */
  screenshare: PresetsUpdateResponseDataPermissionsMediaScreenshare;
  /** Video permissions */
  video: PresetsUpdateResponseDataPermissionsMediaVideo;
}
export const PresetsUpdateResponseDataPermissionsMedia =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      audio: PresetsUpdateResponseDataPermissionsMediaAudio,
      screenshare: PresetsUpdateResponseDataPermissionsMediaScreenshare,
      video: PresetsUpdateResponseDataPermissionsMediaVideo,
    }),
  ).annotate({
    identifier: "PresetsUpdateResponseDataPermissionsMedia",
  }) as any as S.Schema<PresetsUpdateResponseDataPermissionsMedia>;

export type PresetsUpdateResponseDataPermissionsPlugins =
  PresetsCreateRequestPermissionsPlugins;
export const PresetsUpdateResponseDataPermissionsPlugins =
  PresetsCreateRequestPermissionsPlugins;

export type PresetsUpdateResponseDataPermissionsPolls =
  PresetsCreateRequestPermissionsPolls;
export const PresetsUpdateResponseDataPermissionsPolls =
  PresetsCreateRequestPermissionsPolls;

export type PresetsUpdateResponseDataPermissionsRecorderType =
  | "RECORDER"
  | "LIVESTREAMER"
  | "NONE";
export const PresetsUpdateResponseDataPermissionsRecorderType =
  /*@__PURE__*/ S.String;

export type PresetsUpdateResponseDataPermissionsWaitingRoomType =
  | "SKIP"
  | "ON_PRIVILEGED_USER_ENTRY"
  | "SKIP_ON_ACCEPT";
export const PresetsUpdateResponseDataPermissionsWaitingRoomType =
  /*@__PURE__*/ S.String;

export type PresetsUpdateResponseDataPermissionsStageAccess =
  | "ALLOWED"
  | "NOT_ALLOWED"
  | "CAN_REQUEST";
export const PresetsUpdateResponseDataPermissionsStageAccess =
  /*@__PURE__*/ S.String;

export interface PresetsUpdateResponseDataPermissions {
  /** Whether this participant can accept waiting requests */
  acceptWaitingRequests: boolean;
  canAcceptProductionRequests: boolean;
  canChangeParticipantPermissions: boolean;
  canEditDisplayName: boolean;
  canLivestream: boolean;
  canRecord: boolean;
  canSpotlight: boolean;
  chat: PresetsCreateRequestPermissionsChat;
  connectedMeetings: PresetsCreateRequestPermissionsConnectedMeetings;
  disableParticipantAudio: boolean;
  disableParticipantScreensharing: boolean;
  disableParticipantVideo: boolean;
  /** Whether this participant is visible to others or not */
  hiddenParticipant: boolean;
  kickParticipant: boolean;
  /** Media permissions */
  media: PresetsUpdateResponseDataPermissionsMedia;
  pinParticipant: boolean;
  /** Plugin permissions */
  plugins: PresetsCreateRequestPermissionsPlugins;
  /** Poll permissions */
  polls: PresetsCreateRequestPermissionsPolls;
  /** Type of the recording peer */
  recorderType: PresetsUpdateResponseDataPermissionsRecorderType;
  showParticipantList: boolean;
  /** Waiting room type */
  waitingRoomType: PresetsUpdateResponseDataPermissionsWaitingRoomType;
  acceptStageRequests?: boolean | null;
  isRecorder?: boolean | null;
  stageAccess?: PresetsUpdateResponseDataPermissionsStageAccess | null;
  stageEnabled?: boolean | null;
  transcriptionEnabled?: boolean | null;
}
export const PresetsUpdateResponseDataPermissions = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      acceptWaitingRequests: S.Boolean.pipe(T.Body("accept_waiting_requests")),
      canAcceptProductionRequests: S.Boolean.pipe(
        T.Body("can_accept_production_requests"),
      ),
      canChangeParticipantPermissions: S.Boolean.pipe(
        T.Body("can_change_participant_permissions"),
      ),
      canEditDisplayName: S.Boolean.pipe(T.Body("can_edit_display_name")),
      canLivestream: S.Boolean.pipe(T.Body("can_livestream")),
      canRecord: S.Boolean.pipe(T.Body("can_record")),
      canSpotlight: S.Boolean.pipe(T.Body("can_spotlight")),
      chat: PresetsCreateRequestPermissionsChat,
      connectedMeetings: PresetsCreateRequestPermissionsConnectedMeetings.pipe(
        T.Body("connected_meetings"),
      ),
      disableParticipantAudio: S.Boolean.pipe(
        T.Body("disable_participant_audio"),
      ),
      disableParticipantScreensharing: S.Boolean.pipe(
        T.Body("disable_participant_screensharing"),
      ),
      disableParticipantVideo: S.Boolean.pipe(
        T.Body("disable_participant_video"),
      ),
      hiddenParticipant: S.Boolean.pipe(T.Body("hidden_participant")),
      kickParticipant: S.Boolean.pipe(T.Body("kick_participant")),
      media: PresetsUpdateResponseDataPermissionsMedia,
      pinParticipant: S.Boolean.pipe(T.Body("pin_participant")),
      plugins: PresetsCreateRequestPermissionsPlugins,
      polls: PresetsCreateRequestPermissionsPolls,
      recorderType: PresetsUpdateResponseDataPermissionsRecorderType.pipe(
        T.Body("recorder_type"),
      ),
      showParticipantList: S.Boolean.pipe(T.Body("show_participant_list")),
      waitingRoomType: PresetsUpdateResponseDataPermissionsWaitingRoomType.pipe(
        T.Body("waiting_room_type"),
      ),
      acceptStageRequests: S.optional(
        S.NullOr(S.Boolean).pipe(T.Body("accept_stage_requests")),
      ),
      isRecorder: S.optional(S.NullOr(S.Boolean).pipe(T.Body("is_recorder"))),
      stageAccess: S.optional(
        S.NullOr(PresetsUpdateResponseDataPermissionsStageAccess).pipe(
          T.Body("stage_access"),
        ),
      ),
      stageEnabled: S.optional(
        S.NullOr(S.Boolean).pipe(T.Body("stage_enabled")),
      ),
      transcriptionEnabled: S.optional(
        S.NullOr(S.Boolean).pipe(T.Body("transcription_enabled")),
      ),
    }),
).annotate({
  identifier: "PresetsUpdateResponseDataPermissions",
}) as any as S.Schema<PresetsUpdateResponseDataPermissions>;

export type PresetsUpdateResponseDataUiDesignTokensBorderRadius =
  | "sharp"
  | "rounded"
  | "extra-rounded"
  | "circular";
export const PresetsUpdateResponseDataUiDesignTokensBorderRadius =
  /*@__PURE__*/ S.String;

export type PresetsUpdateResponseDataUiDesignTokensBorderWidth =
  | "none"
  | "thin"
  | "fat";
export const PresetsUpdateResponseDataUiDesignTokensBorderWidth =
  /*@__PURE__*/ S.String;

export type PresetsUpdateResponseDataUiDesignTokensColorsBackground =
  PresetsCreateRequestUiDesignTokensColorsBackground;
export const PresetsUpdateResponseDataUiDesignTokensColorsBackground =
  PresetsCreateRequestUiDesignTokensColorsBackground;

export type PresetsUpdateResponseDataUiDesignTokensColorsBrand =
  PresetsCreateRequestUiDesignTokensColorsBrand;
export const PresetsUpdateResponseDataUiDesignTokensColorsBrand =
  PresetsCreateRequestUiDesignTokensColorsBrand;

export type PresetsUpdateResponseDataUiDesignTokensColors =
  PresetsCreateRequestUiDesignTokensColors;
export const PresetsUpdateResponseDataUiDesignTokensColors =
  PresetsCreateRequestUiDesignTokensColors;

export type PresetsUpdateResponseDataUiDesignTokensTheme =
  | "darkest"
  | "dark"
  | "light";
export const PresetsUpdateResponseDataUiDesignTokensTheme =
  /*@__PURE__*/ S.String;

export interface PresetsUpdateResponseDataUiDesignTokens {
  borderRadius: PresetsUpdateResponseDataUiDesignTokensBorderRadius;
  borderWidth: PresetsUpdateResponseDataUiDesignTokensBorderWidth;
  colors: PresetsCreateRequestUiDesignTokensColors;
  spacingBase: number;
  theme: PresetsUpdateResponseDataUiDesignTokensTheme;
  fontFamily?: string | null;
  googleFont?: string | null;
  logo?: string | null;
}
export const PresetsUpdateResponseDataUiDesignTokens = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      borderRadius: PresetsUpdateResponseDataUiDesignTokensBorderRadius.pipe(
        T.Body("border_radius"),
      ),
      borderWidth: PresetsUpdateResponseDataUiDesignTokensBorderWidth.pipe(
        T.Body("border_width"),
      ),
      colors: PresetsCreateRequestUiDesignTokensColors,
      spacingBase: S.Number.pipe(T.Body("spacing_base")),
      theme: PresetsUpdateResponseDataUiDesignTokensTheme,
      fontFamily: S.optional(S.NullOr(S.String).pipe(T.Body("font_family"))),
      googleFont: S.optional(S.NullOr(S.String).pipe(T.Body("google_font"))),
      logo: S.optional(S.NullOr(S.String)),
    }),
).annotate({
  identifier: "PresetsUpdateResponseDataUiDesignTokens",
}) as any as S.Schema<PresetsUpdateResponseDataUiDesignTokens>;

export interface PresetsUpdateResponseDataUi {
  designTokens: PresetsUpdateResponseDataUiDesignTokens;
}
export const PresetsUpdateResponseDataUi = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    designTokens: PresetsUpdateResponseDataUiDesignTokens.pipe(
      T.Body("design_tokens"),
    ),
  }),
).annotate({
  identifier: "PresetsUpdateResponseDataUi",
}) as any as S.Schema<PresetsUpdateResponseDataUi>;

export interface PresetsUpdateResponseData {
  /** ID of the preset */
  id: string;
  config: PresetsUpdateResponseDataConfig;
  /** Timestamp this preset was created at */
  createdAt: string;
  /** Name of the preset */
  name: string;
  permissions: PresetsUpdateResponseDataPermissions;
  ui: PresetsUpdateResponseDataUi;
  /** Timestamp this preset was last updated */
  updatedAt: string;
}
export const PresetsUpdateResponseData = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    config: PresetsUpdateResponseDataConfig,
    createdAt: S.String.pipe(T.Body("created_at")),
    name: S.String,
    permissions: PresetsUpdateResponseDataPermissions,
    ui: PresetsUpdateResponseDataUi,
    updatedAt: S.String.pipe(T.Body("updated_at")),
  }),
).annotate({
  identifier: "PresetsUpdateResponseData",
}) as any as S.Schema<PresetsUpdateResponseData>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface PatchPresetResponse {
  /** Data returned by the operation */
  data: PresetsUpdateResponseData;
}
export const PatchPresetResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    data: PresetsUpdateResponseData,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PatchPresetResponse",
}) as any as S.Schema<PatchPresetResponse>;

export type RecordingsPauseResumeStopRecordingRequestAction =
  | "stop"
  | "pause"
  | "resume";
export const RecordingsPauseResumeStopRecordingRequestAction =
  /*@__PURE__*/ S.String;

export interface PauseResumeStopRecordingRecordingRequest {
  /** The account identifier tag. */
  accountId: string;
  appId: string;
  recordingId: string;
  action: RecordingsPauseResumeStopRecordingRequestAction | (string & {});
}
export const PauseResumeStopRecordingRecordingRequest = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      accountId: S.String.pipe(T.Label("account_id")),
      appId: S.String.pipe(T.Label("app_id")),
      recordingId: S.String.pipe(T.Label("recording_id")),
      action: RecordingsPauseResumeStopRecordingRequestAction,
    })
      .pipe(
        T.Http({
          method: "PUT",
          uri: "/accounts/{account_id}/realtime/kit/{app_id}/recordings/{recording_id}",
          code: 200,
        }),
      )
      .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PauseResumeStopRecordingRecordingRequest",
}) as any as S.Schema<PauseResumeStopRecordingRecordingRequest>;

export type RecordingsPauseResumeStopRecordingResponseDataStatus =
  | "INVOKED"
  | "RECORDING"
  | "UPLOADING"
  | "UPLOADED"
  | "ERRORED"
  | "PAUSED";
export const RecordingsPauseResumeStopRecordingResponseDataStatus =
  /*@__PURE__*/ S.String;

export type RecordingsPauseResumeStopRecordingResponseDataStartReasonCallerType =
  | "ORGANIZATION"
  | "USER";
export const RecordingsPauseResumeStopRecordingResponseDataStartReasonCallerType =
  /*@__PURE__*/ S.String;

export interface RecordingsPauseResumeStopRecordingResponseDataStartReasonCaller {
  /** Name of the user who started the recording. */
  name?: string | null;
  /** The type can be an App or a user. If the type is `user`, then only the `user_Id` and `name` are returned. */
  type?: RecordingsPauseResumeStopRecordingResponseDataStartReasonCallerType | null;
  /** The user ID of the person who started the recording. */
  userId?: string | null;
}
export const RecordingsPauseResumeStopRecordingResponseDataStartReasonCaller =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      name: S.optional(S.NullOr(S.String)),
      type: S.optional(
        S.NullOr(
          RecordingsPauseResumeStopRecordingResponseDataStartReasonCallerType,
        ),
      ),
      userId: S.optional(S.NullOr(S.String).pipe(T.Body("user_Id"))),
    }),
  ).annotate({
    identifier:
      "RecordingsPauseResumeStopRecordingResponseDataStartReasonCaller",
  }) as any as S.Schema<RecordingsPauseResumeStopRecordingResponseDataStartReasonCaller>;

export type RecordingsPauseResumeStopRecordingResponseDataStartReasonReason =
  | "API_CALL"
  | "RECORD_ON_START";
export const RecordingsPauseResumeStopRecordingResponseDataStartReasonReason =
  /*@__PURE__*/ S.String;

export interface RecordingsPauseResumeStopRecordingResponseDataStartReason {
  caller?: RecordingsPauseResumeStopRecordingResponseDataStartReasonCaller | null;
  /** Specifies if the recording was started using the "Start a Recording"API or using the parameter RECORD_ON_START in the "Create a meeting" API. */
  reason?: RecordingsPauseResumeStopRecordingResponseDataStartReasonReason | null;
}
export const RecordingsPauseResumeStopRecordingResponseDataStartReason =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      caller: S.optional(
        S.NullOr(
          RecordingsPauseResumeStopRecordingResponseDataStartReasonCaller,
        ),
      ),
      reason: S.optional(
        S.NullOr(
          RecordingsPauseResumeStopRecordingResponseDataStartReasonReason,
        ),
      ),
    }),
  ).annotate({
    identifier: "RecordingsPauseResumeStopRecordingResponseDataStartReason",
  }) as any as S.Schema<RecordingsPauseResumeStopRecordingResponseDataStartReason>;

export type RecordingsPauseResumeStopRecordingResponseDataStopReasonCallerType =
  | "ORGANIZATION"
  | "USER";
export const RecordingsPauseResumeStopRecordingResponseDataStopReasonCallerType =
  /*@__PURE__*/ S.String;

export interface RecordingsPauseResumeStopRecordingResponseDataStopReasonCaller {
  /** Name of the user who stopped the recording. */
  name?: string | null;
  /** The type can be an App or a user. If the type is `user`, then only the `user_Id` and `name` are returned. */
  type?: RecordingsPauseResumeStopRecordingResponseDataStopReasonCallerType | null;
  /** The user ID of the person who stopped the recording. */
  userId?: string | null;
}
export const RecordingsPauseResumeStopRecordingResponseDataStopReasonCaller =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      name: S.optional(S.NullOr(S.String)),
      type: S.optional(
        S.NullOr(
          RecordingsPauseResumeStopRecordingResponseDataStopReasonCallerType,
        ),
      ),
      userId: S.optional(S.NullOr(S.String).pipe(T.Body("user_Id"))),
    }),
  ).annotate({
    identifier:
      "RecordingsPauseResumeStopRecordingResponseDataStopReasonCaller",
  }) as any as S.Schema<RecordingsPauseResumeStopRecordingResponseDataStopReasonCaller>;

export type RecordingsPauseResumeStopRecordingResponseDataStopReasonReason =
  | "API_CALL"
  | "INTERNAL_ERROR"
  | "ALL_PEERS_LEFT";
export const RecordingsPauseResumeStopRecordingResponseDataStopReasonReason =
  /*@__PURE__*/ S.String;

export interface RecordingsPauseResumeStopRecordingResponseDataStopReason {
  caller?: RecordingsPauseResumeStopRecordingResponseDataStopReasonCaller | null;
  /** Specifies the reason why the recording stopped. */
  reason?: RecordingsPauseResumeStopRecordingResponseDataStopReasonReason | null;
}
export const RecordingsPauseResumeStopRecordingResponseDataStopReason =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      caller: S.optional(
        S.NullOr(
          RecordingsPauseResumeStopRecordingResponseDataStopReasonCaller,
        ),
      ),
      reason: S.optional(
        S.NullOr(
          RecordingsPauseResumeStopRecordingResponseDataStopReasonReason,
        ),
      ),
    }),
  ).annotate({
    identifier: "RecordingsPauseResumeStopRecordingResponseDataStopReason",
  }) as any as S.Schema<RecordingsPauseResumeStopRecordingResponseDataStopReason>;

export type RecordingsPauseResumeStopRecordingResponseDataStorageConfigType =
  | "aws"
  | "azure"
  | "digitalocean"
  | "gcs"
  | "sftp";
export const RecordingsPauseResumeStopRecordingResponseDataStorageConfigType =
  /*@__PURE__*/ S.String;

export type RecordingsPauseResumeStopRecordingResponseDataStorageConfigAuthMethod =
  | "KEY"
  | "PASSWORD";
export const RecordingsPauseResumeStopRecordingResponseDataStorageConfigAuthMethod =
  /*@__PURE__*/ S.String;

export interface RecordingsPauseResumeStopRecordingResponseDataStorageConfig {
  /** Type of storage media. */
  type: RecordingsPauseResumeStopRecordingResponseDataStorageConfigType;
  /** Access key of the storage medium. Access key is not required for the `gcs` storage media type. */
  accessKey?: string | null;
  /** Authentication method used for "sftp" type storage medium */
  authMethod?: RecordingsPauseResumeStopRecordingResponseDataStorageConfigAuthMethod | null;
  /** Name of the storage medium's bucket. */
  bucket?: string | null;
  /** SSH destination server host for SFTP type storage medium */
  host?: string | null;
  /** SSH destination server password for SFTP type storage medium when auth_method is "PASSWORD". If auth_method is "KEY", this specifies the password for the ssh private key. */
  password?: string | null;
  /** Path relative to the bucket root at which the recording will be placed. */
  path?: string | null;
  /** SSH destination server port for SFTP type storage medium */
  port?: number | null;
  /** Private key used to login to destination SSH server for SFTP type storage medium, when auth_method used is "KEY" */
  privateKey?: string | null;
  /** Region of the storage medium. */
  region?: string | null;
  /** Secret key of the storage medium. Similar to `access_key`, it is only writeable by clients, not readable. */
  secret?: string | null;
  /** SSH destination server username for SFTP type storage medium */
  username?: string | null;
}
export const RecordingsPauseResumeStopRecordingResponseDataStorageConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: RecordingsPauseResumeStopRecordingResponseDataStorageConfigType,
      accessKey: S.optional(S.NullOr(S.String).pipe(T.Body("access_key"))),
      authMethod: S.optional(
        S.NullOr(
          RecordingsPauseResumeStopRecordingResponseDataStorageConfigAuthMethod,
        ).pipe(T.Body("auth_method")),
      ),
      bucket: S.optional(S.NullOr(S.String)),
      host: S.optional(S.NullOr(S.String)),
      password: S.optional(S.NullOr(S.String)),
      path: S.optional(S.NullOr(S.String)),
      port: S.optional(S.NullOr(S.Number)),
      privateKey: S.optional(S.NullOr(S.String).pipe(T.Body("private_key"))),
      region: S.optional(S.NullOr(S.String)),
      secret: S.optional(S.NullOr(S.String)),
      username: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier: "RecordingsPauseResumeStopRecordingResponseDataStorageConfig",
  }) as any as S.Schema<RecordingsPauseResumeStopRecordingResponseDataStorageConfig>;

export interface RecordingsPauseResumeStopRecordingResponseData {
  /** ID of the recording */
  id: string;
  /** If the audio_config is passed, the URL for downloading the audio recording is returned. */
  audioDownloadUrl: string;
  /** URL where the recording can be downloaded. */
  downloadUrl: string;
  /** Timestamp when the download URL expires. */
  downloadUrlExpiry: string;
  /** File size of the recording, in bytes. */
  fileSize: number;
  /** Timestamp when this recording was invoked. */
  invokedTime: string;
  /** File name of the recording. */
  outputFileName: string;
  /** ID of the meeting session this recording is for. */
  sessionId: string;
  /** Timestamp when this recording actually started after being invoked. Usually a few seconds after `invoked_time`. */
  startedTime: string;
  /** Current status of the recording. */
  status: RecordingsPauseResumeStopRecordingResponseDataStatus;
  /** Timestamp when this recording was stopped. Optional; is present only when the recording has actually been stopped. */
  stoppedTime: string;
  /** Total recording time in seconds. */
  recordingDuration?: number | null;
  startReason?: RecordingsPauseResumeStopRecordingResponseDataStartReason | null;
  stopReason?: RecordingsPauseResumeStopRecordingResponseDataStopReason | null;
  storageConfig?: RecordingsPauseResumeStopRecordingResponseDataStorageConfig | null;
}
export const RecordingsPauseResumeStopRecordingResponseData =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      audioDownloadUrl: S.String.pipe(T.Body("audio_download_url")),
      downloadUrl: S.String.pipe(T.Body("download_url")),
      downloadUrlExpiry: S.String.pipe(T.Body("download_url_expiry")),
      fileSize: S.Number.pipe(T.Body("file_size")),
      invokedTime: S.String.pipe(T.Body("invoked_time")),
      outputFileName: S.String.pipe(T.Body("output_file_name")),
      sessionId: S.String.pipe(T.Body("session_id")),
      startedTime: S.String.pipe(T.Body("started_time")),
      status: RecordingsPauseResumeStopRecordingResponseDataStatus,
      stoppedTime: S.String.pipe(T.Body("stopped_time")),
      recordingDuration: S.optional(
        S.NullOr(S.Number).pipe(T.Body("recording_duration")),
      ),
      startReason: S.optional(
        S.NullOr(
          RecordingsPauseResumeStopRecordingResponseDataStartReason,
        ).pipe(T.Body("start_reason")),
      ),
      stopReason: S.optional(
        S.NullOr(RecordingsPauseResumeStopRecordingResponseDataStopReason).pipe(
          T.Body("stop_reason"),
        ),
      ),
      storageConfig: S.optional(
        S.NullOr(
          RecordingsPauseResumeStopRecordingResponseDataStorageConfig,
        ).pipe(T.Body("storage_config")),
      ),
    }),
  ).annotate({
    identifier: "RecordingsPauseResumeStopRecordingResponseData",
  }) as any as S.Schema<RecordingsPauseResumeStopRecordingResponseData>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface PauseResumeStopRecordingRecordingResponse {
  /** Data returned by the operation */
  data?: RecordingsPauseResumeStopRecordingResponseData | null;
}
export const PauseResumeStopRecordingRecordingResponse =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      data: S.optional(
        S.NullOr(RecordingsPauseResumeStopRecordingResponseData),
      ),
    }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
  ).annotate({
    identifier: "PauseResumeStopRecordingRecordingResponse",
  }) as any as S.Schema<PauseResumeStopRecordingRecordingResponse>;

export interface PostAppRequest {
  /** The account identifier tag. */
  accountId: string;
  name: string;
}
export const PostAppRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    name: S.String,
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/realtime/kit/apps",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({ identifier: "PostAppRequest" }) as any as S.Schema<PostAppRequest>;

export type AppsPostResponseDataApp = AppsGetResponseDataItem;
export const AppsPostResponseDataApp = AppsGetResponseDataItem;

export interface AppsPostResponseData {
  app?: AppsGetResponseDataItem | null;
}
export const AppsPostResponseData = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    app: S.optional(S.NullOr(AppsGetResponseDataItem)),
  }),
).annotate({
  identifier: "AppsPostResponseData",
}) as any as S.Schema<AppsPostResponseData>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface PostAppResponse {
  data?: AppsPostResponseData | null;
}
export const PostAppResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    data: S.optional(S.NullOr(AppsPostResponseData)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PostAppResponse",
}) as any as S.Schema<PostAppResponse>;

export interface RefreshParticipantTokenMeetingRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  meetingId: string;
  participantId: string;
}
export const RefreshParticipantTokenMeetingRequest = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      accountId: S.String.pipe(T.Label("account_id")),
      appId: S.String.pipe(T.Label("app_id")),
      meetingId: S.String.pipe(T.Label("meeting_id")),
      participantId: S.String.pipe(T.Label("participant_id")),
    })
      .pipe(
        T.Http({
          method: "POST",
          uri: "/accounts/{account_id}/realtime/kit/{app_id}/meetings/{meeting_id}/participants/{participant_id}/token",
          code: 200,
        }),
      )
      .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "RefreshParticipantTokenMeetingRequest",
}) as any as S.Schema<RefreshParticipantTokenMeetingRequest>;

export interface MeetingsRefreshParticipantTokenResponseData {
  /** Regenerated participant's authentication token. */
  token: string;
}
export const MeetingsRefreshParticipantTokenResponseData =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      token: S.String,
    }),
  ).annotate({
    identifier: "MeetingsRefreshParticipantTokenResponseData",
  }) as any as S.Schema<MeetingsRefreshParticipantTokenResponseData>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface RefreshParticipantTokenMeetingResponse {
  /** Data returned by the operation */
  data: MeetingsRefreshParticipantTokenResponseData;
}
export const RefreshParticipantTokenMeetingResponse = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      data: MeetingsRefreshParticipantTokenResponseData,
    }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "RefreshParticipantTokenMeetingResponse",
}) as any as S.Schema<RefreshParticipantTokenMeetingResponse>;

export type MeetingsReplaceMeetingByIdRequestAiConfigSummarizationSummaryType =
  | "general"
  | "team_meeting"
  | "sales_call"
  | "client_check_in"
  | "interview"
  | "daily_standup"
  | "one_on_one_meeting"
  | "lecture"
  | "code_review";
export const MeetingsReplaceMeetingByIdRequestAiConfigSummarizationSummaryType =
  /*@__PURE__*/ S.String;

export type MeetingsReplaceMeetingByIdRequestAiConfigSummarizationTextFormat =
  | "plain_text"
  | "markdown";
export const MeetingsReplaceMeetingByIdRequestAiConfigSummarizationTextFormat =
  /*@__PURE__*/ S.String;

export interface MeetingsReplaceMeetingByIdRequestAiConfigSummarization {
  /** Defines the style of the summary, such as general, team meeting, or sales call. */
  summaryType?:
    | MeetingsReplaceMeetingByIdRequestAiConfigSummarizationSummaryType
    | (string & {});
  /** Determines the text format of the summary, such as plain text or markdown. */
  textFormat?:
    | MeetingsReplaceMeetingByIdRequestAiConfigSummarizationTextFormat
    | (string & {});
  /** Sets the maximum number of words in the meeting summary. */
  wordLimit?: number;
}
export const MeetingsReplaceMeetingByIdRequestAiConfigSummarization =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      summaryType: S.optional(
        MeetingsReplaceMeetingByIdRequestAiConfigSummarizationSummaryType.pipe(
          T.Body("summary_type"),
        ),
      ),
      textFormat: S.optional(
        MeetingsReplaceMeetingByIdRequestAiConfigSummarizationTextFormat.pipe(
          T.Body("text_format"),
        ),
      ),
      wordLimit: S.optional(S.Number.pipe(T.Body("word_limit"))),
    }),
  ).annotate({
    identifier: "MeetingsReplaceMeetingByIdRequestAiConfigSummarization",
  }) as any as S.Schema<MeetingsReplaceMeetingByIdRequestAiConfigSummarization>;

export type MeetingsReplaceMeetingByIdRequestAiConfigTranscriptionKeywordsList =
  Array<string>;
export const MeetingsReplaceMeetingByIdRequestAiConfigTranscriptionKeywordsList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<MeetingsReplaceMeetingByIdRequestAiConfigTranscriptionKeywordsList>;

export type MeetingsReplaceMeetingByIdRequestAiConfigTranscriptionLanguage =
  | "en-US"
  | "en-IN"
  | "de"
  | "hi"
  | "sv"
  | "ru"
  | "pl"
  | "el"
  | "fr"
  | "nl";
export const MeetingsReplaceMeetingByIdRequestAiConfigTranscriptionLanguage =
  /*@__PURE__*/ S.String;

export interface MeetingsReplaceMeetingByIdRequestAiConfigTranscription {
  /** Adds specific terms to improve accurate detection during transcription. */
  keywords?: MeetingsReplaceMeetingByIdRequestAiConfigTranscriptionKeywordsList;
  /** Specifies the language code for transcription to ensure accurate results. */
  language?:
    | MeetingsReplaceMeetingByIdRequestAiConfigTranscriptionLanguage
    | (string & {});
  /** Control the inclusion of offensive language in transcriptions. */
  profanityFilter?: boolean;
}
export const MeetingsReplaceMeetingByIdRequestAiConfigTranscription =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      keywords: S.optional(
        MeetingsReplaceMeetingByIdRequestAiConfigTranscriptionKeywordsList,
      ),
      language: S.optional(
        MeetingsReplaceMeetingByIdRequestAiConfigTranscriptionLanguage,
      ),
      profanityFilter: S.optional(S.Boolean.pipe(T.Body("profanity_filter"))),
    }),
  ).annotate({
    identifier: "MeetingsReplaceMeetingByIdRequestAiConfigTranscription",
  }) as any as S.Schema<MeetingsReplaceMeetingByIdRequestAiConfigTranscription>;

export interface MeetingsReplaceMeetingByIdRequestAiConfig {
  /** Summary Config */
  summarization?: MeetingsReplaceMeetingByIdRequestAiConfigSummarization;
  /** Transcription Configurations */
  transcription?: MeetingsReplaceMeetingByIdRequestAiConfigTranscription;
}
export const MeetingsReplaceMeetingByIdRequestAiConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      summarization: S.optional(
        MeetingsReplaceMeetingByIdRequestAiConfigSummarization,
      ),
      transcription: S.optional(
        MeetingsReplaceMeetingByIdRequestAiConfigTranscription,
      ),
    }),
  ).annotate({
    identifier: "MeetingsReplaceMeetingByIdRequestAiConfig",
  }) as any as S.Schema<MeetingsReplaceMeetingByIdRequestAiConfig>;

export type MeetingsReplaceMeetingByIdRequestRecordingConfigAudioConfigChannel =
  | "mono"
  | "stereo";
export const MeetingsReplaceMeetingByIdRequestRecordingConfigAudioConfigChannel =
  /*@__PURE__*/ S.String;

export type MeetingsReplaceMeetingByIdRequestRecordingConfigAudioConfigCodec =
  | "MP3"
  | "AAC";
export const MeetingsReplaceMeetingByIdRequestRecordingConfigAudioConfigCodec =
  /*@__PURE__*/ S.String;

export interface MeetingsReplaceMeetingByIdRequestRecordingConfigAudioConfig {
  /** Audio signal pathway within an audio file that carries a specific sound source. */
  channel?:
    | MeetingsReplaceMeetingByIdRequestRecordingConfigAudioConfigChannel
    | (string & {});
  /** Codec using which the recording will be encoded. If VP8/VP9 is selected for videoConfig, changing audioConfig is not allowed. In this case, the codec in the audioConfig is automatically set to vorbis. */
  codec?:
    | MeetingsReplaceMeetingByIdRequestRecordingConfigAudioConfigCodec
    | (string & {});
  /** Controls whether to export audio file seperately */
  exportFile?: boolean;
}
export const MeetingsReplaceMeetingByIdRequestRecordingConfigAudioConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      channel: S.optional(
        MeetingsReplaceMeetingByIdRequestRecordingConfigAudioConfigChannel,
      ),
      codec: S.optional(
        MeetingsReplaceMeetingByIdRequestRecordingConfigAudioConfigCodec,
      ),
      exportFile: S.optional(S.Boolean.pipe(T.Body("export_file"))),
    }),
  ).annotate({
    identifier: "MeetingsReplaceMeetingByIdRequestRecordingConfigAudioConfig",
  }) as any as S.Schema<MeetingsReplaceMeetingByIdRequestRecordingConfigAudioConfig>;

export type MeetingsReplaceMeetingByIdRequestRecordingConfigLiveStreamingConfig =
  MeetingsCreateRequestRecordingConfigLiveStreamingConfig;
export const MeetingsReplaceMeetingByIdRequestRecordingConfigLiveStreamingConfig =
  MeetingsCreateRequestRecordingConfigLiveStreamingConfig;

export type MeetingsReplaceMeetingByIdRequestRecordingConfigRealtimekitBucketConfig =
  MeetingsCreateRequestRecordingConfigRealtimekitBucketConfig;
export const MeetingsReplaceMeetingByIdRequestRecordingConfigRealtimekitBucketConfig =
  MeetingsCreateRequestRecordingConfigRealtimekitBucketConfig;

export type MeetingsReplaceMeetingByIdRequestRecordingConfigStorageConfigType =
  | "aws"
  | "azure"
  | "digitalocean"
  | "gcs"
  | "sftp";
export const MeetingsReplaceMeetingByIdRequestRecordingConfigStorageConfigType =
  /*@__PURE__*/ S.String;

export type MeetingsReplaceMeetingByIdRequestRecordingConfigStorageConfigAuthMethod =
  | "KEY"
  | "PASSWORD";
export const MeetingsReplaceMeetingByIdRequestRecordingConfigStorageConfigAuthMethod =
  /*@__PURE__*/ S.String;

export interface MeetingsReplaceMeetingByIdRequestRecordingConfigStorageConfig {
  /** Type of storage media. */
  type:
    | MeetingsReplaceMeetingByIdRequestRecordingConfigStorageConfigType
    | (string & {});
  /** Access key of the storage medium. Access key is not required for the `gcs` storage media type. */
  accessKey?: string;
  /** Authentication method used for "sftp" type storage medium */
  authMethod?:
    | MeetingsReplaceMeetingByIdRequestRecordingConfigStorageConfigAuthMethod
    | (string & {});
  /** Name of the storage medium's bucket. */
  bucket?: string;
  /** SSH destination server host for SFTP type storage medium */
  host?: string;
  /** SSH destination server password for SFTP type storage medium when auth_method is "PASSWORD". If auth_method is "KEY", this specifies the password for the ssh private key. */
  password?: string;
  /** Path relative to the bucket root at which the recording will be placed. */
  path?: string;
  /** SSH destination server port for SFTP type storage medium */
  port?: number;
  /** Private key used to login to destination SSH server for SFTP type storage medium, when auth_method used is "KEY" */
  privateKey?: string;
  /** Region of the storage medium. */
  region?: string;
  /** Secret key of the storage medium. Similar to `access_key`, it is only writeable by clients, not readable. */
  secret?: string;
  /** SSH destination server username for SFTP type storage medium */
  username?: string;
}
export const MeetingsReplaceMeetingByIdRequestRecordingConfigStorageConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: MeetingsReplaceMeetingByIdRequestRecordingConfigStorageConfigType,
      accessKey: S.optional(S.String.pipe(T.Body("access_key"))),
      authMethod: S.optional(
        MeetingsReplaceMeetingByIdRequestRecordingConfigStorageConfigAuthMethod.pipe(
          T.Body("auth_method"),
        ),
      ),
      bucket: S.optional(S.String),
      host: S.optional(S.String),
      password: S.optional(S.String),
      path: S.optional(S.String),
      port: S.optional(S.Number),
      privateKey: S.optional(S.String.pipe(T.Body("private_key"))),
      region: S.optional(S.String),
      secret: S.optional(S.String),
      username: S.optional(S.String),
    }),
  ).annotate({
    identifier: "MeetingsReplaceMeetingByIdRequestRecordingConfigStorageConfig",
  }) as any as S.Schema<MeetingsReplaceMeetingByIdRequestRecordingConfigStorageConfig>;

export type MeetingsReplaceMeetingByIdRequestRecordingConfigVideoConfigCodec =
  | "H264"
  | "VP8";
export const MeetingsReplaceMeetingByIdRequestRecordingConfigVideoConfigCodec =
  /*@__PURE__*/ S.String;

export type MeetingsReplaceMeetingByIdRequestRecordingConfigVideoConfigWatermarkPosition =
  | "left top"
  | "right top"
  | "left bottom"
  | "right bottom";
export const MeetingsReplaceMeetingByIdRequestRecordingConfigVideoConfigWatermarkPosition =
  /*@__PURE__*/ S.String;

export type MeetingsReplaceMeetingByIdRequestRecordingConfigVideoConfigWatermarkSize =
  MeetingsCreateRequestRecordingConfigVideoConfigWatermarkSize;
export const MeetingsReplaceMeetingByIdRequestRecordingConfigVideoConfigWatermarkSize =
  MeetingsCreateRequestRecordingConfigVideoConfigWatermarkSize;

export interface MeetingsReplaceMeetingByIdRequestRecordingConfigVideoConfigWatermark {
  /** Position of the watermark */
  position?:
    | MeetingsReplaceMeetingByIdRequestRecordingConfigVideoConfigWatermarkPosition
    | (string & {});
  /** Size of the watermark */
  size?: MeetingsCreateRequestRecordingConfigVideoConfigWatermarkSize;
  /** URL of the watermark image */
  url?: string;
}
export const MeetingsReplaceMeetingByIdRequestRecordingConfigVideoConfigWatermark =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      position: S.optional(
        MeetingsReplaceMeetingByIdRequestRecordingConfigVideoConfigWatermarkPosition,
      ),
      size: S.optional(
        MeetingsCreateRequestRecordingConfigVideoConfigWatermarkSize,
      ),
      url: S.optional(S.String),
    }),
  ).annotate({
    identifier:
      "MeetingsReplaceMeetingByIdRequestRecordingConfigVideoConfigWatermark",
  }) as any as S.Schema<MeetingsReplaceMeetingByIdRequestRecordingConfigVideoConfigWatermark>;

export interface MeetingsReplaceMeetingByIdRequestRecordingConfigVideoConfig {
  /** Codec using which the recording will be encoded. */
  codec?:
    | MeetingsReplaceMeetingByIdRequestRecordingConfigVideoConfigCodec
    | (string & {});
  /** Controls whether to export video file seperately */
  exportFile?: boolean;
  /** Height of the recording video in pixels */
  height?: number;
  /** Watermark to be added to the recording */
  watermark?: MeetingsReplaceMeetingByIdRequestRecordingConfigVideoConfigWatermark;
  /** Width of the recording video in pixels */
  width?: number;
}
export const MeetingsReplaceMeetingByIdRequestRecordingConfigVideoConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      codec: S.optional(
        MeetingsReplaceMeetingByIdRequestRecordingConfigVideoConfigCodec,
      ),
      exportFile: S.optional(S.Boolean.pipe(T.Body("export_file"))),
      height: S.optional(S.Number),
      watermark: S.optional(
        MeetingsReplaceMeetingByIdRequestRecordingConfigVideoConfigWatermark,
      ),
      width: S.optional(S.Number),
    }),
  ).annotate({
    identifier: "MeetingsReplaceMeetingByIdRequestRecordingConfigVideoConfig",
  }) as any as S.Schema<MeetingsReplaceMeetingByIdRequestRecordingConfigVideoConfig>;

export interface MeetingsReplaceMeetingByIdRequestRecordingConfig {
  /** Object containing configuration regarding the audio that is being recorded. */
  audioConfig?: MeetingsReplaceMeetingByIdRequestRecordingConfigAudioConfig;
  /** Adds a prefix to the beginning of the file name of the recording. */
  fileNamePrefix?: string;
  liveStreamingConfig?: MeetingsCreateRequestRecordingConfigLiveStreamingConfig;
  /** Specifies the maximum duration for recording in seconds, ranging from a minimum of 60 seconds to a maximum of 24 hours. */
  maxSeconds?: number;
  realtimekitBucketConfig?: MeetingsCreateRequestRecordingConfigRealtimekitBucketConfig;
  storageConfig?: MeetingsReplaceMeetingByIdRequestRecordingConfigStorageConfig;
  videoConfig?: MeetingsReplaceMeetingByIdRequestRecordingConfigVideoConfig;
}
export const MeetingsReplaceMeetingByIdRequestRecordingConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      audioConfig: S.optional(
        MeetingsReplaceMeetingByIdRequestRecordingConfigAudioConfig.pipe(
          T.Body("audio_config"),
        ),
      ),
      fileNamePrefix: S.optional(S.String.pipe(T.Body("file_name_prefix"))),
      liveStreamingConfig: S.optional(
        MeetingsCreateRequestRecordingConfigLiveStreamingConfig.pipe(
          T.Body("live_streaming_config"),
        ),
      ),
      maxSeconds: S.optional(S.Number.pipe(T.Body("max_seconds"))),
      realtimekitBucketConfig: S.optional(
        MeetingsCreateRequestRecordingConfigRealtimekitBucketConfig.pipe(
          T.Body("realtimekit_bucket_config"),
        ),
      ),
      storageConfig: S.optional(
        MeetingsReplaceMeetingByIdRequestRecordingConfigStorageConfig.pipe(
          T.Body("storage_config"),
        ),
      ),
      videoConfig: S.optional(
        MeetingsReplaceMeetingByIdRequestRecordingConfigVideoConfig.pipe(
          T.Body("video_config"),
        ),
      ),
    }),
  ).annotate({
    identifier: "MeetingsReplaceMeetingByIdRequestRecordingConfig",
  }) as any as S.Schema<MeetingsReplaceMeetingByIdRequestRecordingConfig>;

export interface ReplaceMeetingByIdMeetingRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  meetingId: string;
  /** The AI Config allows you to customize the behavior of meeting transcriptions and summaries */
  aiConfig?: MeetingsReplaceMeetingByIdRequestAiConfig;
  /** Specifies if the meeting should start getting livestreamed on start. */
  liveStreamOnStart?: boolean;
  /** If a meeting is set to persist_chat, meeting chat would remain for a week within the meeting space. */
  persistChat?: boolean;
  /** Specifies if the meeting should start getting recorded as soon as someone joins the meeting. */
  recordOnStart?: boolean;
  /** Recording Configurations to be used for this meeting. This level of configs takes higher preference over App level configs on the RealtimeKit developer portal. */
  recordingConfig?: MeetingsReplaceMeetingByIdRequestRecordingConfig;
  /** Time in seconds, for which a session remains active, after the last participant has left the meeting. */
  sessionKeepAliveTimeInSecs?: number;
  /** Automatically generate summary of meetings using transcripts. Requires Transcriptions to be enabled, and can be retrieved via Webhooks or summary API. */
  summarizeOnEnd?: boolean;
  /** Title of the meeting */
  title?: string;
  /** Automatically generate transcripts when the meeting ends. */
  transcribeOnEnd?: boolean;
}
export const ReplaceMeetingByIdMeetingRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    appId: S.String.pipe(T.Label("app_id")),
    meetingId: S.String.pipe(T.Label("meeting_id")),
    aiConfig: S.optional(
      MeetingsReplaceMeetingByIdRequestAiConfig.pipe(T.Body("ai_config")),
    ),
    liveStreamOnStart: S.optional(
      S.Boolean.pipe(T.Body("live_stream_on_start")),
    ),
    persistChat: S.optional(S.Boolean.pipe(T.Body("persist_chat"))),
    recordOnStart: S.optional(S.Boolean.pipe(T.Body("record_on_start"))),
    recordingConfig: S.optional(
      MeetingsReplaceMeetingByIdRequestRecordingConfig.pipe(
        T.Body("recording_config"),
      ),
    ),
    sessionKeepAliveTimeInSecs: S.optional(
      S.Number.pipe(T.Body("session_keep_alive_time_in_secs")),
    ),
    summarizeOnEnd: S.optional(S.Boolean.pipe(T.Body("summarize_on_end"))),
    title: S.optional(S.String),
    transcribeOnEnd: S.optional(S.Boolean.pipe(T.Body("transcribe_on_end"))),
  })
    .pipe(
      T.Http({
        method: "PUT",
        uri: "/accounts/{account_id}/realtime/kit/{app_id}/meetings/{meeting_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ReplaceMeetingByIdMeetingRequest",
}) as any as S.Schema<ReplaceMeetingByIdMeetingRequest>;

export type MeetingsReplaceMeetingByIdResponseDataAiConfigSummarizationSummaryType =
  | "general"
  | "team_meeting"
  | "sales_call"
  | "client_check_in"
  | "interview"
  | "daily_standup"
  | "one_on_one_meeting"
  | "lecture"
  | "code_review";
export const MeetingsReplaceMeetingByIdResponseDataAiConfigSummarizationSummaryType =
  /*@__PURE__*/ S.String;

export type MeetingsReplaceMeetingByIdResponseDataAiConfigSummarizationTextFormat =
  | "plain_text"
  | "markdown";
export const MeetingsReplaceMeetingByIdResponseDataAiConfigSummarizationTextFormat =
  /*@__PURE__*/ S.String;

export interface MeetingsReplaceMeetingByIdResponseDataAiConfigSummarization {
  /** Defines the style of the summary, such as general, team meeting, or sales call. */
  summaryType?: MeetingsReplaceMeetingByIdResponseDataAiConfigSummarizationSummaryType | null;
  /** Determines the text format of the summary, such as plain text or markdown. */
  textFormat?: MeetingsReplaceMeetingByIdResponseDataAiConfigSummarizationTextFormat | null;
  /** Sets the maximum number of words in the meeting summary. */
  wordLimit?: number | null;
}
export const MeetingsReplaceMeetingByIdResponseDataAiConfigSummarization =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      summaryType: S.optional(
        S.NullOr(
          MeetingsReplaceMeetingByIdResponseDataAiConfigSummarizationSummaryType,
        ).pipe(T.Body("summary_type")),
      ),
      textFormat: S.optional(
        S.NullOr(
          MeetingsReplaceMeetingByIdResponseDataAiConfigSummarizationTextFormat,
        ).pipe(T.Body("text_format")),
      ),
      wordLimit: S.optional(S.NullOr(S.Number).pipe(T.Body("word_limit"))),
    }),
  ).annotate({
    identifier: "MeetingsReplaceMeetingByIdResponseDataAiConfigSummarization",
  }) as any as S.Schema<MeetingsReplaceMeetingByIdResponseDataAiConfigSummarization>;

export type MeetingsReplaceMeetingByIdResponseDataAiConfigTranscriptionKeywordsList =
  Array<string>;
export const MeetingsReplaceMeetingByIdResponseDataAiConfigTranscriptionKeywordsList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<MeetingsReplaceMeetingByIdResponseDataAiConfigTranscriptionKeywordsList>;

export type MeetingsReplaceMeetingByIdResponseDataAiConfigTranscriptionLanguage =
  | "en-US"
  | "en-IN"
  | "de"
  | "hi"
  | "sv"
  | "ru"
  | "pl"
  | "el"
  | "fr"
  | "nl";
export const MeetingsReplaceMeetingByIdResponseDataAiConfigTranscriptionLanguage =
  /*@__PURE__*/ S.String;

export interface MeetingsReplaceMeetingByIdResponseDataAiConfigTranscription {
  /** Adds specific terms to improve accurate detection during transcription. */
  keywords?: MeetingsReplaceMeetingByIdResponseDataAiConfigTranscriptionKeywordsList | null;
  /** Specifies the language code for transcription to ensure accurate results. */
  language?: MeetingsReplaceMeetingByIdResponseDataAiConfigTranscriptionLanguage | null;
  /** Control the inclusion of offensive language in transcriptions. */
  profanityFilter?: boolean | null;
}
export const MeetingsReplaceMeetingByIdResponseDataAiConfigTranscription =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      keywords: S.optional(
        S.NullOr(
          MeetingsReplaceMeetingByIdResponseDataAiConfigTranscriptionKeywordsList,
        ),
      ),
      language: S.optional(
        S.NullOr(
          MeetingsReplaceMeetingByIdResponseDataAiConfigTranscriptionLanguage,
        ),
      ),
      profanityFilter: S.optional(
        S.NullOr(S.Boolean).pipe(T.Body("profanity_filter")),
      ),
    }),
  ).annotate({
    identifier: "MeetingsReplaceMeetingByIdResponseDataAiConfigTranscription",
  }) as any as S.Schema<MeetingsReplaceMeetingByIdResponseDataAiConfigTranscription>;

export interface MeetingsReplaceMeetingByIdResponseDataAiConfig {
  /** Summary Config */
  summarization?: MeetingsReplaceMeetingByIdResponseDataAiConfigSummarization | null;
  /** Transcription Configurations */
  transcription?: MeetingsReplaceMeetingByIdResponseDataAiConfigTranscription | null;
}
export const MeetingsReplaceMeetingByIdResponseDataAiConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      summarization: S.optional(
        S.NullOr(MeetingsReplaceMeetingByIdResponseDataAiConfigSummarization),
      ),
      transcription: S.optional(
        S.NullOr(MeetingsReplaceMeetingByIdResponseDataAiConfigTranscription),
      ),
    }),
  ).annotate({
    identifier: "MeetingsReplaceMeetingByIdResponseDataAiConfig",
  }) as any as S.Schema<MeetingsReplaceMeetingByIdResponseDataAiConfig>;

export type MeetingsReplaceMeetingByIdResponseDataRecordingConfigAudioConfigChannel =
  | "mono"
  | "stereo";
export const MeetingsReplaceMeetingByIdResponseDataRecordingConfigAudioConfigChannel =
  /*@__PURE__*/ S.String;

export type MeetingsReplaceMeetingByIdResponseDataRecordingConfigAudioConfigCodec =
  | "MP3"
  | "AAC";
export const MeetingsReplaceMeetingByIdResponseDataRecordingConfigAudioConfigCodec =
  /*@__PURE__*/ S.String;

export interface MeetingsReplaceMeetingByIdResponseDataRecordingConfigAudioConfig {
  /** Audio signal pathway within an audio file that carries a specific sound source. */
  channel?: MeetingsReplaceMeetingByIdResponseDataRecordingConfigAudioConfigChannel | null;
  /** Codec using which the recording will be encoded. If VP8/VP9 is selected for videoConfig, changing audioConfig is not allowed. In this case, the codec in the audioConfig is automatically set to vorbis. */
  codec?: MeetingsReplaceMeetingByIdResponseDataRecordingConfigAudioConfigCodec | null;
  /** Controls whether to export audio file seperately */
  exportFile?: boolean | null;
}
export const MeetingsReplaceMeetingByIdResponseDataRecordingConfigAudioConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      channel: S.optional(
        S.NullOr(
          MeetingsReplaceMeetingByIdResponseDataRecordingConfigAudioConfigChannel,
        ),
      ),
      codec: S.optional(
        S.NullOr(
          MeetingsReplaceMeetingByIdResponseDataRecordingConfigAudioConfigCodec,
        ),
      ),
      exportFile: S.optional(S.NullOr(S.Boolean).pipe(T.Body("export_file"))),
    }),
  ).annotate({
    identifier:
      "MeetingsReplaceMeetingByIdResponseDataRecordingConfigAudioConfig",
  }) as any as S.Schema<MeetingsReplaceMeetingByIdResponseDataRecordingConfigAudioConfig>;

export type MeetingsReplaceMeetingByIdResponseDataRecordingConfigLiveStreamingConfig =
  MeetingsCreateResponseDataRecordingConfigLiveStreamingConfig;
export const MeetingsReplaceMeetingByIdResponseDataRecordingConfigLiveStreamingConfig =
  MeetingsCreateResponseDataRecordingConfigLiveStreamingConfig;

export type MeetingsReplaceMeetingByIdResponseDataRecordingConfigRealtimekitBucketConfig =
  MeetingsCreateRequestRecordingConfigRealtimekitBucketConfig;
export const MeetingsReplaceMeetingByIdResponseDataRecordingConfigRealtimekitBucketConfig =
  MeetingsCreateRequestRecordingConfigRealtimekitBucketConfig;

export type MeetingsReplaceMeetingByIdResponseDataRecordingConfigStorageConfigType =
  | "aws"
  | "azure"
  | "digitalocean"
  | "gcs"
  | "sftp";
export const MeetingsReplaceMeetingByIdResponseDataRecordingConfigStorageConfigType =
  /*@__PURE__*/ S.String;

export type MeetingsReplaceMeetingByIdResponseDataRecordingConfigStorageConfigAuthMethod =
  | "KEY"
  | "PASSWORD";
export const MeetingsReplaceMeetingByIdResponseDataRecordingConfigStorageConfigAuthMethod =
  /*@__PURE__*/ S.String;

export interface MeetingsReplaceMeetingByIdResponseDataRecordingConfigStorageConfig {
  /** Type of storage media. */
  type: MeetingsReplaceMeetingByIdResponseDataRecordingConfigStorageConfigType;
  /** Access key of the storage medium. Access key is not required for the `gcs` storage media type. */
  accessKey?: string | null;
  /** Authentication method used for "sftp" type storage medium */
  authMethod?: MeetingsReplaceMeetingByIdResponseDataRecordingConfigStorageConfigAuthMethod | null;
  /** Name of the storage medium's bucket. */
  bucket?: string | null;
  /** SSH destination server host for SFTP type storage medium */
  host?: string | null;
  /** SSH destination server password for SFTP type storage medium when auth_method is "PASSWORD". If auth_method is "KEY", this specifies the password for the ssh private key. */
  password?: string | null;
  /** Path relative to the bucket root at which the recording will be placed. */
  path?: string | null;
  /** SSH destination server port for SFTP type storage medium */
  port?: number | null;
  /** Private key used to login to destination SSH server for SFTP type storage medium, when auth_method used is "KEY" */
  privateKey?: string | null;
  /** Region of the storage medium. */
  region?: string | null;
  /** Secret key of the storage medium. Similar to `access_key`, it is only writeable by clients, not readable. */
  secret?: string | null;
  /** SSH destination server username for SFTP type storage medium */
  username?: string | null;
}
export const MeetingsReplaceMeetingByIdResponseDataRecordingConfigStorageConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: MeetingsReplaceMeetingByIdResponseDataRecordingConfigStorageConfigType,
      accessKey: S.optional(S.NullOr(S.String).pipe(T.Body("access_key"))),
      authMethod: S.optional(
        S.NullOr(
          MeetingsReplaceMeetingByIdResponseDataRecordingConfigStorageConfigAuthMethod,
        ).pipe(T.Body("auth_method")),
      ),
      bucket: S.optional(S.NullOr(S.String)),
      host: S.optional(S.NullOr(S.String)),
      password: S.optional(S.NullOr(S.String)),
      path: S.optional(S.NullOr(S.String)),
      port: S.optional(S.NullOr(S.Number)),
      privateKey: S.optional(S.NullOr(S.String).pipe(T.Body("private_key"))),
      region: S.optional(S.NullOr(S.String)),
      secret: S.optional(S.NullOr(S.String)),
      username: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier:
      "MeetingsReplaceMeetingByIdResponseDataRecordingConfigStorageConfig",
  }) as any as S.Schema<MeetingsReplaceMeetingByIdResponseDataRecordingConfigStorageConfig>;

export type MeetingsReplaceMeetingByIdResponseDataRecordingConfigVideoConfigCodec =
  | "H264"
  | "VP8";
export const MeetingsReplaceMeetingByIdResponseDataRecordingConfigVideoConfigCodec =
  /*@__PURE__*/ S.String;

export type MeetingsReplaceMeetingByIdResponseDataRecordingConfigVideoConfigWatermarkPosition =
  | "left top"
  | "right top"
  | "left bottom"
  | "right bottom";
export const MeetingsReplaceMeetingByIdResponseDataRecordingConfigVideoConfigWatermarkPosition =
  /*@__PURE__*/ S.String;

export type MeetingsReplaceMeetingByIdResponseDataRecordingConfigVideoConfigWatermarkSize =
  MeetingsCreateResponseDataRecordingConfigVideoConfigWatermarkSize;
export const MeetingsReplaceMeetingByIdResponseDataRecordingConfigVideoConfigWatermarkSize =
  MeetingsCreateResponseDataRecordingConfigVideoConfigWatermarkSize;

export interface MeetingsReplaceMeetingByIdResponseDataRecordingConfigVideoConfigWatermark {
  /** Position of the watermark */
  position?: MeetingsReplaceMeetingByIdResponseDataRecordingConfigVideoConfigWatermarkPosition | null;
  /** Size of the watermark */
  size?: MeetingsCreateResponseDataRecordingConfigVideoConfigWatermarkSize | null;
  /** URL of the watermark image */
  url?: string | null;
}
export const MeetingsReplaceMeetingByIdResponseDataRecordingConfigVideoConfigWatermark =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      position: S.optional(
        S.NullOr(
          MeetingsReplaceMeetingByIdResponseDataRecordingConfigVideoConfigWatermarkPosition,
        ),
      ),
      size: S.optional(
        S.NullOr(
          MeetingsCreateResponseDataRecordingConfigVideoConfigWatermarkSize,
        ),
      ),
      url: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier:
      "MeetingsReplaceMeetingByIdResponseDataRecordingConfigVideoConfigWatermark",
  }) as any as S.Schema<MeetingsReplaceMeetingByIdResponseDataRecordingConfigVideoConfigWatermark>;

export interface MeetingsReplaceMeetingByIdResponseDataRecordingConfigVideoConfig {
  /** Codec using which the recording will be encoded. */
  codec?: MeetingsReplaceMeetingByIdResponseDataRecordingConfigVideoConfigCodec | null;
  /** Controls whether to export video file seperately */
  exportFile?: boolean | null;
  /** Height of the recording video in pixels */
  height?: number | null;
  /** Watermark to be added to the recording */
  watermark?: MeetingsReplaceMeetingByIdResponseDataRecordingConfigVideoConfigWatermark | null;
  /** Width of the recording video in pixels */
  width?: number | null;
}
export const MeetingsReplaceMeetingByIdResponseDataRecordingConfigVideoConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      codec: S.optional(
        S.NullOr(
          MeetingsReplaceMeetingByIdResponseDataRecordingConfigVideoConfigCodec,
        ),
      ),
      exportFile: S.optional(S.NullOr(S.Boolean).pipe(T.Body("export_file"))),
      height: S.optional(S.NullOr(S.Number)),
      watermark: S.optional(
        S.NullOr(
          MeetingsReplaceMeetingByIdResponseDataRecordingConfigVideoConfigWatermark,
        ),
      ),
      width: S.optional(S.NullOr(S.Number)),
    }),
  ).annotate({
    identifier:
      "MeetingsReplaceMeetingByIdResponseDataRecordingConfigVideoConfig",
  }) as any as S.Schema<MeetingsReplaceMeetingByIdResponseDataRecordingConfigVideoConfig>;

export interface MeetingsReplaceMeetingByIdResponseDataRecordingConfig {
  /** Object containing configuration regarding the audio that is being recorded. */
  audioConfig?: MeetingsReplaceMeetingByIdResponseDataRecordingConfigAudioConfig | null;
  /** Adds a prefix to the beginning of the file name of the recording. */
  fileNamePrefix?: string | null;
  liveStreamingConfig?: MeetingsCreateResponseDataRecordingConfigLiveStreamingConfig | null;
  /** Specifies the maximum duration for recording in seconds, ranging from a minimum of 60 seconds to a maximum of 24 hours. */
  maxSeconds?: number | null;
  realtimekitBucketConfig?: MeetingsCreateRequestRecordingConfigRealtimekitBucketConfig | null;
  storageConfig?: MeetingsReplaceMeetingByIdResponseDataRecordingConfigStorageConfig | null;
  videoConfig?: MeetingsReplaceMeetingByIdResponseDataRecordingConfigVideoConfig | null;
}
export const MeetingsReplaceMeetingByIdResponseDataRecordingConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      audioConfig: S.optional(
        S.NullOr(
          MeetingsReplaceMeetingByIdResponseDataRecordingConfigAudioConfig,
        ).pipe(T.Body("audio_config")),
      ),
      fileNamePrefix: S.optional(
        S.NullOr(S.String).pipe(T.Body("file_name_prefix")),
      ),
      liveStreamingConfig: S.optional(
        S.NullOr(
          MeetingsCreateResponseDataRecordingConfigLiveStreamingConfig,
        ).pipe(T.Body("live_streaming_config")),
      ),
      maxSeconds: S.optional(S.NullOr(S.Number).pipe(T.Body("max_seconds"))),
      realtimekitBucketConfig: S.optional(
        S.NullOr(
          MeetingsCreateRequestRecordingConfigRealtimekitBucketConfig,
        ).pipe(T.Body("realtimekit_bucket_config")),
      ),
      storageConfig: S.optional(
        S.NullOr(
          MeetingsReplaceMeetingByIdResponseDataRecordingConfigStorageConfig,
        ).pipe(T.Body("storage_config")),
      ),
      videoConfig: S.optional(
        S.NullOr(
          MeetingsReplaceMeetingByIdResponseDataRecordingConfigVideoConfig,
        ).pipe(T.Body("video_config")),
      ),
    }),
  ).annotate({
    identifier: "MeetingsReplaceMeetingByIdResponseDataRecordingConfig",
  }) as any as S.Schema<MeetingsReplaceMeetingByIdResponseDataRecordingConfig>;

export type MeetingsReplaceMeetingByIdResponseDataStatus =
  | "ACTIVE"
  | "INACTIVE";
export const MeetingsReplaceMeetingByIdResponseDataStatus =
  /*@__PURE__*/ S.String;

export interface MeetingsReplaceMeetingByIdResponseData {
  /** ID of the meeting. */
  id: string;
  /** Timestamp the object was created at. The time is returned in ISO format. */
  createdAt: string;
  /** Timestamp the object was updated at. The time is returned in ISO format. */
  updatedAt: string;
  /** The AI Config allows you to customize the behavior of meeting transcriptions and summaries */
  aiConfig?: MeetingsReplaceMeetingByIdResponseDataAiConfig | null;
  /** Specifies if the meeting should start getting livestreamed on start. */
  liveStreamOnStart?: boolean | null;
  /** Specifies if Chat within a meeting should persist for a week. */
  persistChat?: boolean | null;
  /** Specifies if the meeting should start getting recorded as soon as someone joins the meeting. */
  recordOnStart?: boolean | null;
  /** Recording Configurations to be used for this meeting. This level of configs takes higher preference over App level configs on the RealtimeKit developer portal. */
  recordingConfig?: MeetingsReplaceMeetingByIdResponseDataRecordingConfig | null;
  /** Time in seconds, for which a session remains active, after the last participant has left the meeting. */
  sessionKeepAliveTimeInSecs?: number | null;
  /** Whether the meeting is `ACTIVE` or `INACTIVE`. Users will not be able to join an `INACTIVE` meeting. */
  status?: MeetingsReplaceMeetingByIdResponseDataStatus | null;
  /** Automatically generate summary of meetings using transcripts. Requires Transcriptions to be enabled, and can be retrieved via Webhooks or summary API. */
  summarizeOnEnd?: boolean | null;
  /** Title of the meeting. */
  title?: string | null;
  /** Automatically generate transcripts when the meeting ends. */
  transcribeOnEnd?: boolean | null;
}
export const MeetingsReplaceMeetingByIdResponseData = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.String,
      createdAt: S.String.pipe(T.Body("created_at")),
      updatedAt: S.String.pipe(T.Body("updated_at")),
      aiConfig: S.optional(
        S.NullOr(MeetingsReplaceMeetingByIdResponseDataAiConfig).pipe(
          T.Body("ai_config"),
        ),
      ),
      liveStreamOnStart: S.optional(
        S.NullOr(S.Boolean).pipe(T.Body("live_stream_on_start")),
      ),
      persistChat: S.optional(S.NullOr(S.Boolean).pipe(T.Body("persist_chat"))),
      recordOnStart: S.optional(
        S.NullOr(S.Boolean).pipe(T.Body("record_on_start")),
      ),
      recordingConfig: S.optional(
        S.NullOr(MeetingsReplaceMeetingByIdResponseDataRecordingConfig).pipe(
          T.Body("recording_config"),
        ),
      ),
      sessionKeepAliveTimeInSecs: S.optional(
        S.NullOr(S.Number).pipe(T.Body("session_keep_alive_time_in_secs")),
      ),
      status: S.optional(
        S.NullOr(MeetingsReplaceMeetingByIdResponseDataStatus),
      ),
      summarizeOnEnd: S.optional(
        S.NullOr(S.Boolean).pipe(T.Body("summarize_on_end")),
      ),
      title: S.optional(S.NullOr(S.String)),
      transcribeOnEnd: S.optional(
        S.NullOr(S.Boolean).pipe(T.Body("transcribe_on_end")),
      ),
    }),
).annotate({
  identifier: "MeetingsReplaceMeetingByIdResponseData",
}) as any as S.Schema<MeetingsReplaceMeetingByIdResponseData>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface ReplaceMeetingByIdMeetingResponse {
  /** Data returned by the operation */
  data?: MeetingsReplaceMeetingByIdResponseData | null;
}
export const ReplaceMeetingByIdMeetingResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    data: S.optional(S.NullOr(MeetingsReplaceMeetingByIdResponseData)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ReplaceMeetingByIdMeetingResponse",
}) as any as S.Schema<ReplaceMeetingByIdMeetingResponse>;

export type WebhooksReplaceWebhookRequestEventsItem =
  | "meeting.started"
  | "meeting.ended"
  | "meeting.participantJoined"
  | "meeting.participantLeft"
  | "meeting.chatSynced"
  | "recording.statusUpdate"
  | "livestreaming.statusUpdate"
  | "meeting.transcript"
  | "meeting.summary";
export const WebhooksReplaceWebhookRequestEventsItem = /*@__PURE__*/ S.String;

export type WebhooksReplaceWebhookRequestEventsList = Array<
  WebhooksReplaceWebhookRequestEventsItem | (string & {})
>;
export const WebhooksReplaceWebhookRequestEventsList = /*@__PURE__*/ S.Array(
  WebhooksReplaceWebhookRequestEventsItem,
) as any as S.Schema<WebhooksReplaceWebhookRequestEventsList>;

export interface ReplaceWebhookWebhookRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  webhookId: string;
  /** Events that this webhook will get triggered by */
  events: WebhooksReplaceWebhookRequestEventsList;
  /** Name of the webhook */
  name: string;
  /** URL this webhook will send events to */
  url: string;
  /** Set whether or not the webhook should be active when created */
  enabled?: boolean;
}
export const ReplaceWebhookWebhookRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    appId: S.String.pipe(T.Label("app_id")),
    webhookId: S.String.pipe(T.Label("webhook_id")),
    events: WebhooksReplaceWebhookRequestEventsList,
    name: S.String,
    url: S.String,
    enabled: S.optional(S.Boolean),
  })
    .pipe(
      T.Http({
        method: "PUT",
        uri: "/accounts/{account_id}/realtime/kit/{app_id}/webhooks/{webhook_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ReplaceWebhookWebhookRequest",
}) as any as S.Schema<ReplaceWebhookWebhookRequest>;

export type WebhooksReplaceWebhookResponseDataEventsItem =
  | "meeting.started"
  | "meeting.ended"
  | "meeting.participantJoined"
  | "meeting.participantLeft"
  | "meeting.chatSynced"
  | "recording.statusUpdate"
  | "livestreaming.statusUpdate"
  | "meeting.transcript"
  | "meeting.summary";
export const WebhooksReplaceWebhookResponseDataEventsItem =
  /*@__PURE__*/ S.String;

export type WebhooksReplaceWebhookResponseDataEventsList =
  Array<WebhooksReplaceWebhookResponseDataEventsItem>;
export const WebhooksReplaceWebhookResponseDataEventsList =
  /*@__PURE__*/ S.Array(
    WebhooksReplaceWebhookResponseDataEventsItem,
  ) as any as S.Schema<WebhooksReplaceWebhookResponseDataEventsList>;

export interface WebhooksReplaceWebhookResponseData {
  /** ID of the webhook */
  id: string;
  /** Timestamp when this webhook was created */
  createdAt: string;
  /** Set to true if the webhook is active */
  enabled: boolean;
  /** Events this webhook will send updates for */
  events: WebhooksReplaceWebhookResponseDataEventsList;
  /** Name of the webhook */
  name: string;
  /** Timestamp when this webhook was updated */
  updatedAt: string;
  /** URL the webhook will send events to */
  url: string;
}
export const WebhooksReplaceWebhookResponseData = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    createdAt: S.String.pipe(T.Body("created_at")),
    enabled: S.Boolean,
    events: WebhooksReplaceWebhookResponseDataEventsList,
    name: S.String,
    updatedAt: S.String.pipe(T.Body("updated_at")),
    url: S.String,
  }),
).annotate({
  identifier: "WebhooksReplaceWebhookResponseData",
}) as any as S.Schema<WebhooksReplaceWebhookResponseData>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface ReplaceWebhookWebhookResponse {
  data: WebhooksReplaceWebhookResponseData;
}
export const ReplaceWebhookWebhookResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    data: WebhooksReplaceWebhookResponseData,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ReplaceWebhookWebhookResponse",
}) as any as S.Schema<ReplaceWebhookWebhookResponse>;

export interface LivestreamsStartLivestreamingAMeetingRequestVideoConfig {
  /** Height of the livestreaming video in pixels */
  height?: number;
  /** Width of the livestreaming video in pixels */
  width?: number;
}
export const LivestreamsStartLivestreamingAMeetingRequestVideoConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      height: S.optional(S.Number),
      width: S.optional(S.Number),
    }),
  ).annotate({
    identifier: "LivestreamsStartLivestreamingAMeetingRequestVideoConfig",
  }) as any as S.Schema<LivestreamsStartLivestreamingAMeetingRequestVideoConfig>;

export interface StartLivestreamingAMeetingLivestreamRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  meetingId: string;
  name?: string;
  videoConfig?: LivestreamsStartLivestreamingAMeetingRequestVideoConfig;
}
export const StartLivestreamingAMeetingLivestreamRequest =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      accountId: S.String.pipe(T.Label("account_id")),
      appId: S.String.pipe(T.Label("app_id")),
      meetingId: S.String.pipe(T.Label("meeting_id")),
      name: S.optional(S.String),
      videoConfig: S.optional(
        LivestreamsStartLivestreamingAMeetingRequestVideoConfig.pipe(
          T.Body("video_config"),
        ),
      ),
    })
      .pipe(
        T.Http({
          method: "POST",
          uri: "/accounts/{account_id}/realtime/kit/{app_id}/meetings/{meeting_id}/livestreams",
          code: 200,
        }),
      )
      .pipe(T.KeyDictionary(KEY_DICTIONARY)),
  ).annotate({
    identifier: "StartLivestreamingAMeetingLivestreamRequest",
  }) as any as S.Schema<StartLivestreamingAMeetingLivestreamRequest>;

export type LivestreamsStartLivestreamingAMeetingResponseDataStatus =
  | "LIVE"
  | "IDLE"
  | "ERRORED"
  | "INVOKED";
export const LivestreamsStartLivestreamingAMeetingResponseDataStatus =
  /*@__PURE__*/ S.String;

export interface LivestreamsStartLivestreamingAMeetingResponseData {
  /** The livestream ID. */
  id?: string | null;
  /** The server URL to which the RTMP encoder sends the video and audio data. */
  ingestServer?: string | null;
  /** The web address that viewers can use to watch the livestream. */
  playbackUrl?: string | null;
  status?: LivestreamsStartLivestreamingAMeetingResponseDataStatus | null;
  /** Unique key for accessing each livestream. */
  streamKey?: string | null;
}
export const LivestreamsStartLivestreamingAMeetingResponseData =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.optional(S.NullOr(S.String)),
      ingestServer: S.optional(
        S.NullOr(S.String).pipe(T.Body("ingest_server")),
      ),
      playbackUrl: S.optional(S.NullOr(S.String).pipe(T.Body("playback_url"))),
      status: S.optional(
        S.NullOr(LivestreamsStartLivestreamingAMeetingResponseDataStatus),
      ),
      streamKey: S.optional(S.NullOr(S.String).pipe(T.Body("stream_key"))),
    }),
  ).annotate({
    identifier: "LivestreamsStartLivestreamingAMeetingResponseData",
  }) as any as S.Schema<LivestreamsStartLivestreamingAMeetingResponseData>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface StartLivestreamingAMeetingLivestreamResponse {
  data?: LivestreamsStartLivestreamingAMeetingResponseData | null;
}
export const StartLivestreamingAMeetingLivestreamResponse =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      data: S.optional(
        S.NullOr(LivestreamsStartLivestreamingAMeetingResponseData),
      ),
    }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
  ).annotate({
    identifier: "StartLivestreamingAMeetingLivestreamResponse",
  }) as any as S.Schema<StartLivestreamingAMeetingLivestreamResponse>;

export type RecordingsStartRecordingsRequestAudioConfigChannel =
  | "mono"
  | "stereo";
export const RecordingsStartRecordingsRequestAudioConfigChannel =
  /*@__PURE__*/ S.String;

export type RecordingsStartRecordingsRequestAudioConfigCodec = "MP3" | "AAC";
export const RecordingsStartRecordingsRequestAudioConfigCodec =
  /*@__PURE__*/ S.String;

export interface RecordingsStartRecordingsRequestAudioConfig {
  /** Audio signal pathway within an audio file that carries a specific sound source. */
  channel?: RecordingsStartRecordingsRequestAudioConfigChannel | (string & {});
  /** Codec using which the recording will be encoded. If VP8/VP9 is selected for videoConfig, changing audioConfig is not allowed. In this case, the codec in the audioConfig is automatically set to vorbis. */
  codec?: RecordingsStartRecordingsRequestAudioConfigCodec | (string & {});
  /** Controls whether to export audio file seperately */
  exportFile?: boolean;
}
export const RecordingsStartRecordingsRequestAudioConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      channel: S.optional(RecordingsStartRecordingsRequestAudioConfigChannel),
      codec: S.optional(RecordingsStartRecordingsRequestAudioConfigCodec),
      exportFile: S.optional(S.Boolean.pipe(T.Body("export_file"))),
    }),
  ).annotate({
    identifier: "RecordingsStartRecordingsRequestAudioConfig",
  }) as any as S.Schema<RecordingsStartRecordingsRequestAudioConfig>;

export type RecordingsStartRecordingsRequestInteractiveConfigType = "ID3";
export const RecordingsStartRecordingsRequestInteractiveConfigType =
  /*@__PURE__*/ S.String;

export interface RecordingsStartRecordingsRequestInteractiveConfig {
  /** The metadata is presented in the form of ID3 tags. */
  type?: RecordingsStartRecordingsRequestInteractiveConfigType | (string & {});
}
export const RecordingsStartRecordingsRequestInteractiveConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: S.optional(RecordingsStartRecordingsRequestInteractiveConfigType),
    }),
  ).annotate({
    identifier: "RecordingsStartRecordingsRequestInteractiveConfig",
  }) as any as S.Schema<RecordingsStartRecordingsRequestInteractiveConfig>;

export type RecordingsStartRecordingsRequestRealtimekitBucketConfig =
  MeetingsCreateRequestRecordingConfigRealtimekitBucketConfig;
export const RecordingsStartRecordingsRequestRealtimekitBucketConfig =
  MeetingsCreateRequestRecordingConfigRealtimekitBucketConfig;

export type RecordingsStartRecordingsRequestRtmpOutConfig =
  MeetingsCreateRequestRecordingConfigLiveStreamingConfig;
export const RecordingsStartRecordingsRequestRtmpOutConfig =
  MeetingsCreateRequestRecordingConfigLiveStreamingConfig;

export type RecordingsStartRecordingsRequestStorageConfigType =
  | "aws"
  | "azure"
  | "digitalocean"
  | "gcs"
  | "sftp";
export const RecordingsStartRecordingsRequestStorageConfigType =
  /*@__PURE__*/ S.String;

export type RecordingsStartRecordingsRequestStorageConfigAuthMethod =
  | "KEY"
  | "PASSWORD";
export const RecordingsStartRecordingsRequestStorageConfigAuthMethod =
  /*@__PURE__*/ S.String;

export interface RecordingsStartRecordingsRequestStorageConfig {
  /** Type of storage media. */
  type: RecordingsStartRecordingsRequestStorageConfigType | (string & {});
  /** Access key of the storage medium. Access key is not required for the `gcs` storage media type. */
  accessKey?: string;
  /** Authentication method used for "sftp" type storage medium */
  authMethod?:
    | RecordingsStartRecordingsRequestStorageConfigAuthMethod
    | (string & {});
  /** Name of the storage medium's bucket. */
  bucket?: string;
  /** SSH destination server host for SFTP type storage medium */
  host?: string;
  /** SSH destination server password for SFTP type storage medium when auth_method is "PASSWORD". If auth_method is "KEY", this specifies the password for the ssh private key. */
  password?: string;
  /** Path relative to the bucket root at which the recording will be placed. */
  path?: string;
  /** SSH destination server port for SFTP type storage medium */
  port?: number;
  /** Private key used to login to destination SSH server for SFTP type storage medium, when auth_method used is "KEY" */
  privateKey?: string;
  /** Region of the storage medium. */
  region?: string;
  /** Secret key of the storage medium. Similar to `access_key`, it is only writeable by clients, not readable. */
  secret?: string;
  /** SSH destination server username for SFTP type storage medium */
  username?: string;
}
export const RecordingsStartRecordingsRequestStorageConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: RecordingsStartRecordingsRequestStorageConfigType,
      accessKey: S.optional(S.String.pipe(T.Body("access_key"))),
      authMethod: S.optional(
        RecordingsStartRecordingsRequestStorageConfigAuthMethod.pipe(
          T.Body("auth_method"),
        ),
      ),
      bucket: S.optional(S.String),
      host: S.optional(S.String),
      password: S.optional(S.String),
      path: S.optional(S.String),
      port: S.optional(S.Number),
      privateKey: S.optional(S.String.pipe(T.Body("private_key"))),
      region: S.optional(S.String),
      secret: S.optional(S.String),
      username: S.optional(S.String),
    }),
  ).annotate({
    identifier: "RecordingsStartRecordingsRequestStorageConfig",
  }) as any as S.Schema<RecordingsStartRecordingsRequestStorageConfig>;

export type RecordingsStartRecordingsRequestVideoConfigCodec = "H264" | "VP8";
export const RecordingsStartRecordingsRequestVideoConfigCodec =
  /*@__PURE__*/ S.String;

export type RecordingsStartRecordingsRequestVideoConfigWatermarkPosition =
  | "left top"
  | "right top"
  | "left bottom"
  | "right bottom";
export const RecordingsStartRecordingsRequestVideoConfigWatermarkPosition =
  /*@__PURE__*/ S.String;

export type RecordingsStartRecordingsRequestVideoConfigWatermarkSize =
  MeetingsCreateRequestRecordingConfigVideoConfigWatermarkSize;
export const RecordingsStartRecordingsRequestVideoConfigWatermarkSize =
  MeetingsCreateRequestRecordingConfigVideoConfigWatermarkSize;

export interface RecordingsStartRecordingsRequestVideoConfigWatermark {
  /** Position of the watermark */
  position?:
    | RecordingsStartRecordingsRequestVideoConfigWatermarkPosition
    | (string & {});
  /** Size of the watermark */
  size?: MeetingsCreateRequestRecordingConfigVideoConfigWatermarkSize;
  /** URL of the watermark image */
  url?: string;
}
export const RecordingsStartRecordingsRequestVideoConfigWatermark =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      position: S.optional(
        RecordingsStartRecordingsRequestVideoConfigWatermarkPosition,
      ),
      size: S.optional(
        MeetingsCreateRequestRecordingConfigVideoConfigWatermarkSize,
      ),
      url: S.optional(S.String),
    }),
  ).annotate({
    identifier: "RecordingsStartRecordingsRequestVideoConfigWatermark",
  }) as any as S.Schema<RecordingsStartRecordingsRequestVideoConfigWatermark>;

export interface RecordingsStartRecordingsRequestVideoConfig {
  /** Codec using which the recording will be encoded. */
  codec?: RecordingsStartRecordingsRequestVideoConfigCodec | (string & {});
  /** Controls whether to export video file seperately */
  exportFile?: boolean;
  /** Height of the recording video in pixels */
  height?: number;
  /** Watermark to be added to the recording */
  watermark?: RecordingsStartRecordingsRequestVideoConfigWatermark;
  /** Width of the recording video in pixels */
  width?: number;
}
export const RecordingsStartRecordingsRequestVideoConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      codec: S.optional(RecordingsStartRecordingsRequestVideoConfigCodec),
      exportFile: S.optional(S.Boolean.pipe(T.Body("export_file"))),
      height: S.optional(S.Number),
      watermark: S.optional(
        RecordingsStartRecordingsRequestVideoConfigWatermark,
      ),
      width: S.optional(S.Number),
    }),
  ).annotate({
    identifier: "RecordingsStartRecordingsRequestVideoConfig",
  }) as any as S.Schema<RecordingsStartRecordingsRequestVideoConfig>;

export interface StartRecordingsRecordingRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  /** ID of the meeting to record. */
  meetingId: string;
  /** By default, a meeting allows only one recording to run at a time. Enabling the `allow_multiple_recordings` parameter to true allows you to initiate multiple recordings concurrently in the same meeting. This allows you to record separate videos of the same meeting with different configurations, such as portrait mode or landscape mode. */
  allowMultipleRecordings?: boolean;
  /** Object containing configuration regarding the audio that is being recorded. */
  audioConfig?: RecordingsStartRecordingsRequestAudioConfig;
  /** Update the recording file name. */
  fileNamePrefix?: string;
  /** Allows you to add timed metadata to your recordings, which are digital markers inserted into a video file to provide contextual information at specific points in the content range. The ID3 tags containing this information are available to clients on the playback timeline in HLS format. The output files are generated in a compressed .tar format. */
  interactiveConfig?: RecordingsStartRecordingsRequestInteractiveConfig;
  /** Specifies the maximum duration for recording in seconds, ranging from a minimum of 60 seconds to a maximum of 24 hours. */
  maxSeconds?: number;
  realtimekitBucketConfig?: MeetingsCreateRequestRecordingConfigRealtimekitBucketConfig;
  rtmpOutConfig?: MeetingsCreateRequestRecordingConfigLiveStreamingConfig;
  storageConfig?: RecordingsStartRecordingsRequestStorageConfig;
  /** Pass a custom url to record arbitary screen */
  url?: string;
  videoConfig?: RecordingsStartRecordingsRequestVideoConfig;
}
export const StartRecordingsRecordingRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    appId: S.String.pipe(T.Label("app_id")),
    meetingId: S.String.pipe(T.Body("meeting_id")),
    allowMultipleRecordings: S.optional(
      S.Boolean.pipe(T.Body("allow_multiple_recordings")),
    ),
    audioConfig: S.optional(
      RecordingsStartRecordingsRequestAudioConfig.pipe(T.Body("audio_config")),
    ),
    fileNamePrefix: S.optional(S.String.pipe(T.Body("file_name_prefix"))),
    interactiveConfig: S.optional(
      RecordingsStartRecordingsRequestInteractiveConfig.pipe(
        T.Body("interactive_config"),
      ),
    ),
    maxSeconds: S.optional(S.Number.pipe(T.Body("max_seconds"))),
    realtimekitBucketConfig: S.optional(
      MeetingsCreateRequestRecordingConfigRealtimekitBucketConfig.pipe(
        T.Body("realtimekit_bucket_config"),
      ),
    ),
    rtmpOutConfig: S.optional(
      MeetingsCreateRequestRecordingConfigLiveStreamingConfig.pipe(
        T.Body("rtmp_out_config"),
      ),
    ),
    storageConfig: S.optional(
      RecordingsStartRecordingsRequestStorageConfig.pipe(
        T.Body("storage_config"),
      ),
    ),
    url: S.optional(S.String),
    videoConfig: S.optional(
      RecordingsStartRecordingsRequestVideoConfig.pipe(T.Body("video_config")),
    ),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/realtime/kit/{app_id}/recordings",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "StartRecordingsRecordingRequest",
}) as any as S.Schema<StartRecordingsRecordingRequest>;

export type RecordingsStartRecordingsResponseDataStatus =
  | "INVOKED"
  | "RECORDING"
  | "UPLOADING"
  | "UPLOADED"
  | "ERRORED"
  | "PAUSED";
export const RecordingsStartRecordingsResponseDataStatus =
  /*@__PURE__*/ S.String;

export type RecordingsStartRecordingsResponseDataStartReasonCallerType =
  | "ORGANIZATION"
  | "USER";
export const RecordingsStartRecordingsResponseDataStartReasonCallerType =
  /*@__PURE__*/ S.String;

export interface RecordingsStartRecordingsResponseDataStartReasonCaller {
  /** Name of the user who started the recording. */
  name?: string | null;
  /** The type can be an App or a user. If the type is `user`, then only the `user_Id` and `name` are returned. */
  type?: RecordingsStartRecordingsResponseDataStartReasonCallerType | null;
  /** The user ID of the person who started the recording. */
  userId?: string | null;
}
export const RecordingsStartRecordingsResponseDataStartReasonCaller =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      name: S.optional(S.NullOr(S.String)),
      type: S.optional(
        S.NullOr(RecordingsStartRecordingsResponseDataStartReasonCallerType),
      ),
      userId: S.optional(S.NullOr(S.String).pipe(T.Body("user_Id"))),
    }),
  ).annotate({
    identifier: "RecordingsStartRecordingsResponseDataStartReasonCaller",
  }) as any as S.Schema<RecordingsStartRecordingsResponseDataStartReasonCaller>;

export type RecordingsStartRecordingsResponseDataStartReasonReason =
  | "API_CALL"
  | "RECORD_ON_START";
export const RecordingsStartRecordingsResponseDataStartReasonReason =
  /*@__PURE__*/ S.String;

export interface RecordingsStartRecordingsResponseDataStartReason {
  caller?: RecordingsStartRecordingsResponseDataStartReasonCaller | null;
  /** Specifies if the recording was started using the "Start a Recording"API or using the parameter RECORD_ON_START in the "Create a meeting" API. */
  reason?: RecordingsStartRecordingsResponseDataStartReasonReason | null;
}
export const RecordingsStartRecordingsResponseDataStartReason =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      caller: S.optional(
        S.NullOr(RecordingsStartRecordingsResponseDataStartReasonCaller),
      ),
      reason: S.optional(
        S.NullOr(RecordingsStartRecordingsResponseDataStartReasonReason),
      ),
    }),
  ).annotate({
    identifier: "RecordingsStartRecordingsResponseDataStartReason",
  }) as any as S.Schema<RecordingsStartRecordingsResponseDataStartReason>;

export type RecordingsStartRecordingsResponseDataStopReasonCallerType =
  | "ORGANIZATION"
  | "USER";
export const RecordingsStartRecordingsResponseDataStopReasonCallerType =
  /*@__PURE__*/ S.String;

export interface RecordingsStartRecordingsResponseDataStopReasonCaller {
  /** Name of the user who stopped the recording. */
  name?: string | null;
  /** The type can be an App or a user. If the type is `user`, then only the `user_Id` and `name` are returned. */
  type?: RecordingsStartRecordingsResponseDataStopReasonCallerType | null;
  /** The user ID of the person who stopped the recording. */
  userId?: string | null;
}
export const RecordingsStartRecordingsResponseDataStopReasonCaller =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      name: S.optional(S.NullOr(S.String)),
      type: S.optional(
        S.NullOr(RecordingsStartRecordingsResponseDataStopReasonCallerType),
      ),
      userId: S.optional(S.NullOr(S.String).pipe(T.Body("user_Id"))),
    }),
  ).annotate({
    identifier: "RecordingsStartRecordingsResponseDataStopReasonCaller",
  }) as any as S.Schema<RecordingsStartRecordingsResponseDataStopReasonCaller>;

export type RecordingsStartRecordingsResponseDataStopReasonReason =
  | "API_CALL"
  | "INTERNAL_ERROR"
  | "ALL_PEERS_LEFT";
export const RecordingsStartRecordingsResponseDataStopReasonReason =
  /*@__PURE__*/ S.String;

export interface RecordingsStartRecordingsResponseDataStopReason {
  caller?: RecordingsStartRecordingsResponseDataStopReasonCaller | null;
  /** Specifies the reason why the recording stopped. */
  reason?: RecordingsStartRecordingsResponseDataStopReasonReason | null;
}
export const RecordingsStartRecordingsResponseDataStopReason =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      caller: S.optional(
        S.NullOr(RecordingsStartRecordingsResponseDataStopReasonCaller),
      ),
      reason: S.optional(
        S.NullOr(RecordingsStartRecordingsResponseDataStopReasonReason),
      ),
    }),
  ).annotate({
    identifier: "RecordingsStartRecordingsResponseDataStopReason",
  }) as any as S.Schema<RecordingsStartRecordingsResponseDataStopReason>;

export type RecordingsStartRecordingsResponseDataStorageConfigType =
  | "aws"
  | "azure"
  | "digitalocean"
  | "gcs"
  | "sftp";
export const RecordingsStartRecordingsResponseDataStorageConfigType =
  /*@__PURE__*/ S.String;

export type RecordingsStartRecordingsResponseDataStorageConfigAuthMethod =
  | "KEY"
  | "PASSWORD";
export const RecordingsStartRecordingsResponseDataStorageConfigAuthMethod =
  /*@__PURE__*/ S.String;

export interface RecordingsStartRecordingsResponseDataStorageConfig {
  /** Type of storage media. */
  type: RecordingsStartRecordingsResponseDataStorageConfigType;
  /** Access key of the storage medium. Access key is not required for the `gcs` storage media type. */
  accessKey?: string | null;
  /** Authentication method used for "sftp" type storage medium */
  authMethod?: RecordingsStartRecordingsResponseDataStorageConfigAuthMethod | null;
  /** Name of the storage medium's bucket. */
  bucket?: string | null;
  /** SSH destination server host for SFTP type storage medium */
  host?: string | null;
  /** SSH destination server password for SFTP type storage medium when auth_method is "PASSWORD". If auth_method is "KEY", this specifies the password for the ssh private key. */
  password?: string | null;
  /** Path relative to the bucket root at which the recording will be placed. */
  path?: string | null;
  /** SSH destination server port for SFTP type storage medium */
  port?: number | null;
  /** Private key used to login to destination SSH server for SFTP type storage medium, when auth_method used is "KEY" */
  privateKey?: string | null;
  /** Region of the storage medium. */
  region?: string | null;
  /** Secret key of the storage medium. Similar to `access_key`, it is only writeable by clients, not readable. */
  secret?: string | null;
  /** SSH destination server username for SFTP type storage medium */
  username?: string | null;
}
export const RecordingsStartRecordingsResponseDataStorageConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: RecordingsStartRecordingsResponseDataStorageConfigType,
      accessKey: S.optional(S.NullOr(S.String).pipe(T.Body("access_key"))),
      authMethod: S.optional(
        S.NullOr(
          RecordingsStartRecordingsResponseDataStorageConfigAuthMethod,
        ).pipe(T.Body("auth_method")),
      ),
      bucket: S.optional(S.NullOr(S.String)),
      host: S.optional(S.NullOr(S.String)),
      password: S.optional(S.NullOr(S.String)),
      path: S.optional(S.NullOr(S.String)),
      port: S.optional(S.NullOr(S.Number)),
      privateKey: S.optional(S.NullOr(S.String).pipe(T.Body("private_key"))),
      region: S.optional(S.NullOr(S.String)),
      secret: S.optional(S.NullOr(S.String)),
      username: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier: "RecordingsStartRecordingsResponseDataStorageConfig",
  }) as any as S.Schema<RecordingsStartRecordingsResponseDataStorageConfig>;

export interface RecordingsStartRecordingsResponseData {
  /** ID of the recording */
  id: string;
  /** If the audio_config is passed, the URL for downloading the audio recording is returned. */
  audioDownloadUrl: string;
  /** URL where the recording can be downloaded. */
  downloadUrl: string;
  /** Timestamp when the download URL expires. */
  downloadUrlExpiry: string;
  /** File size of the recording, in bytes. */
  fileSize: number;
  /** Timestamp when this recording was invoked. */
  invokedTime: string;
  /** File name of the recording. */
  outputFileName: string;
  /** ID of the meeting session this recording is for. */
  sessionId: string;
  /** Timestamp when this recording actually started after being invoked. Usually a few seconds after `invoked_time`. */
  startedTime: string;
  /** Current status of the recording. */
  status: RecordingsStartRecordingsResponseDataStatus;
  /** Timestamp when this recording was stopped. Optional; is present only when the recording has actually been stopped. */
  stoppedTime: string;
  /** Total recording time in seconds. */
  recordingDuration?: number | null;
  startReason?: RecordingsStartRecordingsResponseDataStartReason | null;
  stopReason?: RecordingsStartRecordingsResponseDataStopReason | null;
  storageConfig?: RecordingsStartRecordingsResponseDataStorageConfig | null;
}
export const RecordingsStartRecordingsResponseData = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.String,
      audioDownloadUrl: S.String.pipe(T.Body("audio_download_url")),
      downloadUrl: S.String.pipe(T.Body("download_url")),
      downloadUrlExpiry: S.String.pipe(T.Body("download_url_expiry")),
      fileSize: S.Number.pipe(T.Body("file_size")),
      invokedTime: S.String.pipe(T.Body("invoked_time")),
      outputFileName: S.String.pipe(T.Body("output_file_name")),
      sessionId: S.String.pipe(T.Body("session_id")),
      startedTime: S.String.pipe(T.Body("started_time")),
      status: RecordingsStartRecordingsResponseDataStatus,
      stoppedTime: S.String.pipe(T.Body("stopped_time")),
      recordingDuration: S.optional(
        S.NullOr(S.Number).pipe(T.Body("recording_duration")),
      ),
      startReason: S.optional(
        S.NullOr(RecordingsStartRecordingsResponseDataStartReason).pipe(
          T.Body("start_reason"),
        ),
      ),
      stopReason: S.optional(
        S.NullOr(RecordingsStartRecordingsResponseDataStopReason).pipe(
          T.Body("stop_reason"),
        ),
      ),
      storageConfig: S.optional(
        S.NullOr(RecordingsStartRecordingsResponseDataStorageConfig).pipe(
          T.Body("storage_config"),
        ),
      ),
    }),
).annotate({
  identifier: "RecordingsStartRecordingsResponseData",
}) as any as S.Schema<RecordingsStartRecordingsResponseData>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface StartRecordingsRecordingResponse {
  /** Data returned by the operation */
  data?: RecordingsStartRecordingsResponseData | null;
}
export const StartRecordingsRecordingResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    data: S.optional(S.NullOr(RecordingsStartRecordingsResponseData)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "StartRecordingsRecordingResponse",
}) as any as S.Schema<StartRecordingsRecordingResponse>;

export type RecordingsStartTrackRecordingRequestLayersValueMediaKind = "audio";
export const RecordingsStartTrackRecordingRequestLayersValueMediaKind =
  /*@__PURE__*/ S.String;

export interface RecordingsStartTrackRecordingRequestLayersValue {
  /** A file name prefix to apply for files generated from this layer */
  fileNamePrefix?: string;
  /** Media kind to record. Track recording currently supports audio only. */
  mediaKind?:
    | RecordingsStartTrackRecordingRequestLayersValueMediaKind
    | (string & {});
}
export const RecordingsStartTrackRecordingRequestLayersValue =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      fileNamePrefix: S.optional(S.String.pipe(T.Body("file_name_prefix"))),
      mediaKind: S.optional(
        RecordingsStartTrackRecordingRequestLayersValueMediaKind.pipe(
          T.Body("media_kind"),
        ),
      ),
    }),
  ).annotate({
    identifier: "RecordingsStartTrackRecordingRequestLayersValue",
  }) as any as S.Schema<RecordingsStartTrackRecordingRequestLayersValue>;

export type RecordingsStartTrackRecordingRequestLayersMap = {
  [key: string]: RecordingsStartTrackRecordingRequestLayersValue | undefined;
};
export const RecordingsStartTrackRecordingRequestLayersMap =
  /*@__PURE__*/ S.Record(
    S.String,
    RecordingsStartTrackRecordingRequestLayersValue,
  ) as any as S.Schema<RecordingsStartTrackRecordingRequestLayersMap>;

export type RecordingsStartTrackRecordingRequestUserIdsList = Array<string>;
export const RecordingsStartTrackRecordingRequestUserIdsList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<RecordingsStartTrackRecordingRequestUserIdsList>;

export interface StartTrackRecordingRecordingRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  /** ID of the meeting to record. */
  meetingId: string;
  /** Optional audio layer configuration. If omitted, RealtimeKit records all participant audio using the default file name prefix. */
  layers?: RecordingsStartTrackRecordingRequestLayersMap;
  /** Optional list of participant user IDs to record. Selective track recording (`user_ids`) is in early beta contact support to use this feature. */
  userIds?: RecordingsStartTrackRecordingRequestUserIdsList;
}
export const StartTrackRecordingRecordingRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    appId: S.String.pipe(T.Label("app_id")),
    meetingId: S.String.pipe(T.Body("meeting_id")),
    layers: S.optional(RecordingsStartTrackRecordingRequestLayersMap),
    userIds: S.optional(
      RecordingsStartTrackRecordingRequestUserIdsList.pipe(T.Body("user_ids")),
    ),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/realtime/kit/{app_id}/recordings/track",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "StartTrackRecordingRecordingRequest",
}) as any as S.Schema<StartTrackRecordingRecordingRequest>;

export type RecordingsStartTrackRecordingResponseDataRecordingStatus =
  | "INVOKED"
  | "RECORDING"
  | "UPLOADING"
  | "UPLOADED"
  | "ERRORED"
  | "PAUSED";
export const RecordingsStartTrackRecordingResponseDataRecordingStatus =
  /*@__PURE__*/ S.String;

export interface RecordingsStartTrackRecordingResponseDataRecording {
  /** ID of the recording */
  id: string;
  /** If the audio_config is passed, the URL for downloading the audio recording is returned. */
  audioDownloadUrl: string;
  /** URL where the recording can be downloaded. */
  downloadUrl: string;
  /** Timestamp when the download URL expires. */
  downloadUrlExpiry: string;
  /** File size of the recording, in bytes. */
  fileSize: number;
  /** Timestamp when this recording was invoked. */
  invokedTime: string;
  /** File name of the recording. */
  outputFileName: string;
  /** ID of the meeting session this recording is for. */
  sessionId: string;
  /** Timestamp when this recording actually started after being invoked. Usually a few seconds after `invoked_time`. */
  startedTime: string;
  /** Current status of the recording. */
  status: RecordingsStartTrackRecordingResponseDataRecordingStatus;
  /** Timestamp when this recording was stopped. Optional; is present only when the recording has actually been stopped. */
  stoppedTime: string;
  /** Total recording time in seconds. */
  recordingDuration?: number | null;
}
export const RecordingsStartTrackRecordingResponseDataRecording =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      audioDownloadUrl: S.String.pipe(T.Body("audio_download_url")),
      downloadUrl: S.String.pipe(T.Body("download_url")),
      downloadUrlExpiry: S.String.pipe(T.Body("download_url_expiry")),
      fileSize: S.Number.pipe(T.Body("file_size")),
      invokedTime: S.String.pipe(T.Body("invoked_time")),
      outputFileName: S.String.pipe(T.Body("output_file_name")),
      sessionId: S.String.pipe(T.Body("session_id")),
      startedTime: S.String.pipe(T.Body("started_time")),
      status: RecordingsStartTrackRecordingResponseDataRecordingStatus,
      stoppedTime: S.String.pipe(T.Body("stopped_time")),
      recordingDuration: S.optional(
        S.NullOr(S.Number).pipe(T.Body("recording_duration")),
      ),
    }),
  ).annotate({
    identifier: "RecordingsStartTrackRecordingResponseDataRecording",
  }) as any as S.Schema<RecordingsStartTrackRecordingResponseDataRecording>;

export interface RecordingsStartTrackRecordingResponseData {
  recording: RecordingsStartTrackRecordingResponseDataRecording;
}
export const RecordingsStartTrackRecordingResponseData =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      recording: RecordingsStartTrackRecordingResponseDataRecording,
    }),
  ).annotate({
    identifier: "RecordingsStartTrackRecordingResponseData",
  }) as any as S.Schema<RecordingsStartTrackRecordingResponseData>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface StartTrackRecordingRecordingResponse {
  /** Data returned by the operation */
  data?: RecordingsStartTrackRecordingResponseData | null;
}
export const StartTrackRecordingRecordingResponse = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      data: S.optional(S.NullOr(RecordingsStartTrackRecordingResponseData)),
    }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "StartTrackRecordingRecordingResponse",
}) as any as S.Schema<StartTrackRecordingRecordingResponse>;

export interface StopLivestreamingAMeetingLivestreamRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  meetingId: string;
}
export const StopLivestreamingAMeetingLivestreamRequest =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      accountId: S.String.pipe(T.Label("account_id")),
      appId: S.String.pipe(T.Label("app_id")),
      meetingId: S.String.pipe(T.Label("meeting_id")),
    })
      .pipe(
        T.Http({
          method: "POST",
          uri: "/accounts/{account_id}/realtime/kit/{app_id}/meetings/{meeting_id}/active-livestream/stop",
          code: 200,
        }),
      )
      .pipe(T.KeyDictionary(KEY_DICTIONARY)),
  ).annotate({
    identifier: "StopLivestreamingAMeetingLivestreamRequest",
  }) as any as S.Schema<StopLivestreamingAMeetingLivestreamRequest>;

export interface LivestreamsStopLivestreamingAMeetingResponseData {
  message?: string | null;
}
export const LivestreamsStopLivestreamingAMeetingResponseData =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      message: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier: "LivestreamsStopLivestreamingAMeetingResponseData",
  }) as any as S.Schema<LivestreamsStopLivestreamingAMeetingResponseData>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface StopLivestreamingAMeetingLivestreamResponse {
  data?: LivestreamsStopLivestreamingAMeetingResponseData | null;
}
export const StopLivestreamingAMeetingLivestreamResponse =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      data: S.optional(
        S.NullOr(LivestreamsStopLivestreamingAMeetingResponseData),
      ),
    }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
  ).annotate({
    identifier: "StopLivestreamingAMeetingLivestreamResponse",
  }) as any as S.Schema<StopLivestreamingAMeetingLivestreamResponse>;

export type MeetingsUpdateMeetingByIdRequestAiConfigSummarizationSummaryType =
  | "general"
  | "team_meeting"
  | "sales_call"
  | "client_check_in"
  | "interview"
  | "daily_standup"
  | "one_on_one_meeting"
  | "lecture"
  | "code_review";
export const MeetingsUpdateMeetingByIdRequestAiConfigSummarizationSummaryType =
  /*@__PURE__*/ S.String;

export type MeetingsUpdateMeetingByIdRequestAiConfigSummarizationTextFormat =
  | "plain_text"
  | "markdown";
export const MeetingsUpdateMeetingByIdRequestAiConfigSummarizationTextFormat =
  /*@__PURE__*/ S.String;

export interface MeetingsUpdateMeetingByIdRequestAiConfigSummarization {
  /** Defines the style of the summary, such as general, team meeting, or sales call. */
  summaryType?:
    | MeetingsUpdateMeetingByIdRequestAiConfigSummarizationSummaryType
    | (string & {});
  /** Determines the text format of the summary, such as plain text or markdown. */
  textFormat?:
    | MeetingsUpdateMeetingByIdRequestAiConfigSummarizationTextFormat
    | (string & {});
  /** Sets the maximum number of words in the meeting summary. */
  wordLimit?: number;
}
export const MeetingsUpdateMeetingByIdRequestAiConfigSummarization =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      summaryType: S.optional(
        MeetingsUpdateMeetingByIdRequestAiConfigSummarizationSummaryType.pipe(
          T.Body("summary_type"),
        ),
      ),
      textFormat: S.optional(
        MeetingsUpdateMeetingByIdRequestAiConfigSummarizationTextFormat.pipe(
          T.Body("text_format"),
        ),
      ),
      wordLimit: S.optional(S.Number.pipe(T.Body("word_limit"))),
    }),
  ).annotate({
    identifier: "MeetingsUpdateMeetingByIdRequestAiConfigSummarization",
  }) as any as S.Schema<MeetingsUpdateMeetingByIdRequestAiConfigSummarization>;

export type MeetingsUpdateMeetingByIdRequestAiConfigTranscriptionKeywordsList =
  Array<string>;
export const MeetingsUpdateMeetingByIdRequestAiConfigTranscriptionKeywordsList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<MeetingsUpdateMeetingByIdRequestAiConfigTranscriptionKeywordsList>;

export type MeetingsUpdateMeetingByIdRequestAiConfigTranscriptionLanguage =
  | "en-US"
  | "en-IN"
  | "de"
  | "hi"
  | "sv"
  | "ru"
  | "pl"
  | "el"
  | "fr"
  | "nl";
export const MeetingsUpdateMeetingByIdRequestAiConfigTranscriptionLanguage =
  /*@__PURE__*/ S.String;

export interface MeetingsUpdateMeetingByIdRequestAiConfigTranscription {
  /** Adds specific terms to improve accurate detection during transcription. */
  keywords?: MeetingsUpdateMeetingByIdRequestAiConfigTranscriptionKeywordsList;
  /** Specifies the language code for transcription to ensure accurate results. */
  language?:
    | MeetingsUpdateMeetingByIdRequestAiConfigTranscriptionLanguage
    | (string & {});
  /** Control the inclusion of offensive language in transcriptions. */
  profanityFilter?: boolean;
}
export const MeetingsUpdateMeetingByIdRequestAiConfigTranscription =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      keywords: S.optional(
        MeetingsUpdateMeetingByIdRequestAiConfigTranscriptionKeywordsList,
      ),
      language: S.optional(
        MeetingsUpdateMeetingByIdRequestAiConfigTranscriptionLanguage,
      ),
      profanityFilter: S.optional(S.Boolean.pipe(T.Body("profanity_filter"))),
    }),
  ).annotate({
    identifier: "MeetingsUpdateMeetingByIdRequestAiConfigTranscription",
  }) as any as S.Schema<MeetingsUpdateMeetingByIdRequestAiConfigTranscription>;

export interface MeetingsUpdateMeetingByIdRequestAiConfig {
  /** Summary Config */
  summarization?: MeetingsUpdateMeetingByIdRequestAiConfigSummarization;
  /** Transcription Configurations */
  transcription?: MeetingsUpdateMeetingByIdRequestAiConfigTranscription;
}
export const MeetingsUpdateMeetingByIdRequestAiConfig = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      summarization: S.optional(
        MeetingsUpdateMeetingByIdRequestAiConfigSummarization,
      ),
      transcription: S.optional(
        MeetingsUpdateMeetingByIdRequestAiConfigTranscription,
      ),
    }),
).annotate({
  identifier: "MeetingsUpdateMeetingByIdRequestAiConfig",
}) as any as S.Schema<MeetingsUpdateMeetingByIdRequestAiConfig>;

export type MeetingsUpdateMeetingByIdRequestRecordingConfigAudioConfigChannel =
  | "mono"
  | "stereo";
export const MeetingsUpdateMeetingByIdRequestRecordingConfigAudioConfigChannel =
  /*@__PURE__*/ S.String;

export type MeetingsUpdateMeetingByIdRequestRecordingConfigAudioConfigCodec =
  | "MP3"
  | "AAC";
export const MeetingsUpdateMeetingByIdRequestRecordingConfigAudioConfigCodec =
  /*@__PURE__*/ S.String;

export interface MeetingsUpdateMeetingByIdRequestRecordingConfigAudioConfig {
  /** Audio signal pathway within an audio file that carries a specific sound source. */
  channel?:
    | MeetingsUpdateMeetingByIdRequestRecordingConfigAudioConfigChannel
    | (string & {});
  /** Codec using which the recording will be encoded. If VP8/VP9 is selected for videoConfig, changing audioConfig is not allowed. In this case, the codec in the audioConfig is automatically set to vorbis. */
  codec?:
    | MeetingsUpdateMeetingByIdRequestRecordingConfigAudioConfigCodec
    | (string & {});
  /** Controls whether to export audio file seperately */
  exportFile?: boolean;
}
export const MeetingsUpdateMeetingByIdRequestRecordingConfigAudioConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      channel: S.optional(
        MeetingsUpdateMeetingByIdRequestRecordingConfigAudioConfigChannel,
      ),
      codec: S.optional(
        MeetingsUpdateMeetingByIdRequestRecordingConfigAudioConfigCodec,
      ),
      exportFile: S.optional(S.Boolean.pipe(T.Body("export_file"))),
    }),
  ).annotate({
    identifier: "MeetingsUpdateMeetingByIdRequestRecordingConfigAudioConfig",
  }) as any as S.Schema<MeetingsUpdateMeetingByIdRequestRecordingConfigAudioConfig>;

export type MeetingsUpdateMeetingByIdRequestRecordingConfigLiveStreamingConfig =
  MeetingsCreateRequestRecordingConfigLiveStreamingConfig;
export const MeetingsUpdateMeetingByIdRequestRecordingConfigLiveStreamingConfig =
  MeetingsCreateRequestRecordingConfigLiveStreamingConfig;

export type MeetingsUpdateMeetingByIdRequestRecordingConfigRealtimekitBucketConfig =
  MeetingsCreateRequestRecordingConfigRealtimekitBucketConfig;
export const MeetingsUpdateMeetingByIdRequestRecordingConfigRealtimekitBucketConfig =
  MeetingsCreateRequestRecordingConfigRealtimekitBucketConfig;

export type MeetingsUpdateMeetingByIdRequestRecordingConfigStorageConfigType =
  | "aws"
  | "azure"
  | "digitalocean"
  | "gcs"
  | "sftp";
export const MeetingsUpdateMeetingByIdRequestRecordingConfigStorageConfigType =
  /*@__PURE__*/ S.String;

export type MeetingsUpdateMeetingByIdRequestRecordingConfigStorageConfigAuthMethod =
  | "KEY"
  | "PASSWORD";
export const MeetingsUpdateMeetingByIdRequestRecordingConfigStorageConfigAuthMethod =
  /*@__PURE__*/ S.String;

export interface MeetingsUpdateMeetingByIdRequestRecordingConfigStorageConfig {
  /** Type of storage media. */
  type:
    | MeetingsUpdateMeetingByIdRequestRecordingConfigStorageConfigType
    | (string & {});
  /** Access key of the storage medium. Access key is not required for the `gcs` storage media type. */
  accessKey?: string;
  /** Authentication method used for "sftp" type storage medium */
  authMethod?:
    | MeetingsUpdateMeetingByIdRequestRecordingConfigStorageConfigAuthMethod
    | (string & {});
  /** Name of the storage medium's bucket. */
  bucket?: string;
  /** SSH destination server host for SFTP type storage medium */
  host?: string;
  /** SSH destination server password for SFTP type storage medium when auth_method is "PASSWORD". If auth_method is "KEY", this specifies the password for the ssh private key. */
  password?: string;
  /** Path relative to the bucket root at which the recording will be placed. */
  path?: string;
  /** SSH destination server port for SFTP type storage medium */
  port?: number;
  /** Private key used to login to destination SSH server for SFTP type storage medium, when auth_method used is "KEY" */
  privateKey?: string;
  /** Region of the storage medium. */
  region?: string;
  /** Secret key of the storage medium. Similar to `access_key`, it is only writeable by clients, not readable. */
  secret?: string;
  /** SSH destination server username for SFTP type storage medium */
  username?: string;
}
export const MeetingsUpdateMeetingByIdRequestRecordingConfigStorageConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: MeetingsUpdateMeetingByIdRequestRecordingConfigStorageConfigType,
      accessKey: S.optional(S.String.pipe(T.Body("access_key"))),
      authMethod: S.optional(
        MeetingsUpdateMeetingByIdRequestRecordingConfigStorageConfigAuthMethod.pipe(
          T.Body("auth_method"),
        ),
      ),
      bucket: S.optional(S.String),
      host: S.optional(S.String),
      password: S.optional(S.String),
      path: S.optional(S.String),
      port: S.optional(S.Number),
      privateKey: S.optional(S.String.pipe(T.Body("private_key"))),
      region: S.optional(S.String),
      secret: S.optional(S.String),
      username: S.optional(S.String),
    }),
  ).annotate({
    identifier: "MeetingsUpdateMeetingByIdRequestRecordingConfigStorageConfig",
  }) as any as S.Schema<MeetingsUpdateMeetingByIdRequestRecordingConfigStorageConfig>;

export type MeetingsUpdateMeetingByIdRequestRecordingConfigVideoConfigCodec =
  | "H264"
  | "VP8";
export const MeetingsUpdateMeetingByIdRequestRecordingConfigVideoConfigCodec =
  /*@__PURE__*/ S.String;

export type MeetingsUpdateMeetingByIdRequestRecordingConfigVideoConfigWatermarkPosition =
  | "left top"
  | "right top"
  | "left bottom"
  | "right bottom";
export const MeetingsUpdateMeetingByIdRequestRecordingConfigVideoConfigWatermarkPosition =
  /*@__PURE__*/ S.String;

export type MeetingsUpdateMeetingByIdRequestRecordingConfigVideoConfigWatermarkSize =
  MeetingsCreateRequestRecordingConfigVideoConfigWatermarkSize;
export const MeetingsUpdateMeetingByIdRequestRecordingConfigVideoConfigWatermarkSize =
  MeetingsCreateRequestRecordingConfigVideoConfigWatermarkSize;

export interface MeetingsUpdateMeetingByIdRequestRecordingConfigVideoConfigWatermark {
  /** Position of the watermark */
  position?:
    | MeetingsUpdateMeetingByIdRequestRecordingConfigVideoConfigWatermarkPosition
    | (string & {});
  /** Size of the watermark */
  size?: MeetingsCreateRequestRecordingConfigVideoConfigWatermarkSize;
  /** URL of the watermark image */
  url?: string;
}
export const MeetingsUpdateMeetingByIdRequestRecordingConfigVideoConfigWatermark =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      position: S.optional(
        MeetingsUpdateMeetingByIdRequestRecordingConfigVideoConfigWatermarkPosition,
      ),
      size: S.optional(
        MeetingsCreateRequestRecordingConfigVideoConfigWatermarkSize,
      ),
      url: S.optional(S.String),
    }),
  ).annotate({
    identifier:
      "MeetingsUpdateMeetingByIdRequestRecordingConfigVideoConfigWatermark",
  }) as any as S.Schema<MeetingsUpdateMeetingByIdRequestRecordingConfigVideoConfigWatermark>;

export interface MeetingsUpdateMeetingByIdRequestRecordingConfigVideoConfig {
  /** Codec using which the recording will be encoded. */
  codec?:
    | MeetingsUpdateMeetingByIdRequestRecordingConfigVideoConfigCodec
    | (string & {});
  /** Controls whether to export video file seperately */
  exportFile?: boolean;
  /** Height of the recording video in pixels */
  height?: number;
  /** Watermark to be added to the recording */
  watermark?: MeetingsUpdateMeetingByIdRequestRecordingConfigVideoConfigWatermark;
  /** Width of the recording video in pixels */
  width?: number;
}
export const MeetingsUpdateMeetingByIdRequestRecordingConfigVideoConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      codec: S.optional(
        MeetingsUpdateMeetingByIdRequestRecordingConfigVideoConfigCodec,
      ),
      exportFile: S.optional(S.Boolean.pipe(T.Body("export_file"))),
      height: S.optional(S.Number),
      watermark: S.optional(
        MeetingsUpdateMeetingByIdRequestRecordingConfigVideoConfigWatermark,
      ),
      width: S.optional(S.Number),
    }),
  ).annotate({
    identifier: "MeetingsUpdateMeetingByIdRequestRecordingConfigVideoConfig",
  }) as any as S.Schema<MeetingsUpdateMeetingByIdRequestRecordingConfigVideoConfig>;

export interface MeetingsUpdateMeetingByIdRequestRecordingConfig {
  /** Object containing configuration regarding the audio that is being recorded. */
  audioConfig?: MeetingsUpdateMeetingByIdRequestRecordingConfigAudioConfig;
  /** Adds a prefix to the beginning of the file name of the recording. */
  fileNamePrefix?: string;
  liveStreamingConfig?: MeetingsCreateRequestRecordingConfigLiveStreamingConfig;
  /** Specifies the maximum duration for recording in seconds, ranging from a minimum of 60 seconds to a maximum of 24 hours. */
  maxSeconds?: number;
  realtimekitBucketConfig?: MeetingsCreateRequestRecordingConfigRealtimekitBucketConfig;
  storageConfig?: MeetingsUpdateMeetingByIdRequestRecordingConfigStorageConfig;
  videoConfig?: MeetingsUpdateMeetingByIdRequestRecordingConfigVideoConfig;
}
export const MeetingsUpdateMeetingByIdRequestRecordingConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      audioConfig: S.optional(
        MeetingsUpdateMeetingByIdRequestRecordingConfigAudioConfig.pipe(
          T.Body("audio_config"),
        ),
      ),
      fileNamePrefix: S.optional(S.String.pipe(T.Body("file_name_prefix"))),
      liveStreamingConfig: S.optional(
        MeetingsCreateRequestRecordingConfigLiveStreamingConfig.pipe(
          T.Body("live_streaming_config"),
        ),
      ),
      maxSeconds: S.optional(S.Number.pipe(T.Body("max_seconds"))),
      realtimekitBucketConfig: S.optional(
        MeetingsCreateRequestRecordingConfigRealtimekitBucketConfig.pipe(
          T.Body("realtimekit_bucket_config"),
        ),
      ),
      storageConfig: S.optional(
        MeetingsUpdateMeetingByIdRequestRecordingConfigStorageConfig.pipe(
          T.Body("storage_config"),
        ),
      ),
      videoConfig: S.optional(
        MeetingsUpdateMeetingByIdRequestRecordingConfigVideoConfig.pipe(
          T.Body("video_config"),
        ),
      ),
    }),
  ).annotate({
    identifier: "MeetingsUpdateMeetingByIdRequestRecordingConfig",
  }) as any as S.Schema<MeetingsUpdateMeetingByIdRequestRecordingConfig>;

export type MeetingsUpdateMeetingByIdRequestStatus = "ACTIVE" | "INACTIVE";
export const MeetingsUpdateMeetingByIdRequestStatus = /*@__PURE__*/ S.String;

export interface UpdateMeetingByIdMeetingRequest {
  /** The account identifier tag. */
  accountId: string;
  /** The app identifier tag. */
  appId: string;
  meetingId: string;
  /** The AI Config allows you to customize the behavior of meeting transcriptions and summaries */
  aiConfig?: MeetingsUpdateMeetingByIdRequestAiConfig;
  /** Specifies if the meeting should start getting livestreamed on start. */
  liveStreamOnStart?: boolean;
  /** If a meeting is updated to persist_chat, meeting chat would remain for a week within the meeting space. */
  persistChat?: boolean;
  /** Specifies if the meeting should start getting recorded as soon as someone joins the meeting. */
  recordOnStart?: boolean;
  /** Recording Configurations to be used for this meeting. This level of configs takes higher preference over App level configs on the RealtimeKit developer portal. */
  recordingConfig?: MeetingsUpdateMeetingByIdRequestRecordingConfig;
  /** Time in seconds, for which a session remains active, after the last participant has left the meeting. */
  sessionKeepAliveTimeInSecs?: number;
  /** Whether the meeting is `ACTIVE` or `INACTIVE`. Users will not be able to join an `INACTIVE` meeting. */
  status?: MeetingsUpdateMeetingByIdRequestStatus | (string & {});
  /** Automatically generate summary of meetings using transcripts. Requires Transcriptions to be enabled, and can be retrieved via Webhooks or summary API. */
  summarizeOnEnd?: boolean;
  /** Title of the meeting */
  title?: string;
  /** Automatically generate transcripts when the meeting ends. */
  transcribeOnEnd?: boolean;
}
export const UpdateMeetingByIdMeetingRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    appId: S.String.pipe(T.Label("app_id")),
    meetingId: S.String.pipe(T.Label("meeting_id")),
    aiConfig: S.optional(
      MeetingsUpdateMeetingByIdRequestAiConfig.pipe(T.Body("ai_config")),
    ),
    liveStreamOnStart: S.optional(
      S.Boolean.pipe(T.Body("live_stream_on_start")),
    ),
    persistChat: S.optional(S.Boolean.pipe(T.Body("persist_chat"))),
    recordOnStart: S.optional(S.Boolean.pipe(T.Body("record_on_start"))),
    recordingConfig: S.optional(
      MeetingsUpdateMeetingByIdRequestRecordingConfig.pipe(
        T.Body("recording_config"),
      ),
    ),
    sessionKeepAliveTimeInSecs: S.optional(
      S.Number.pipe(T.Body("session_keep_alive_time_in_secs")),
    ),
    status: S.optional(MeetingsUpdateMeetingByIdRequestStatus),
    summarizeOnEnd: S.optional(S.Boolean.pipe(T.Body("summarize_on_end"))),
    title: S.optional(S.String),
    transcribeOnEnd: S.optional(S.Boolean.pipe(T.Body("transcribe_on_end"))),
  })
    .pipe(
      T.Http({
        method: "PATCH",
        uri: "/accounts/{account_id}/realtime/kit/{app_id}/meetings/{meeting_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "UpdateMeetingByIdMeetingRequest",
}) as any as S.Schema<UpdateMeetingByIdMeetingRequest>;

export type MeetingsUpdateMeetingByIdResponseDataAiConfigSummarizationSummaryType =
  | "general"
  | "team_meeting"
  | "sales_call"
  | "client_check_in"
  | "interview"
  | "daily_standup"
  | "one_on_one_meeting"
  | "lecture"
  | "code_review";
export const MeetingsUpdateMeetingByIdResponseDataAiConfigSummarizationSummaryType =
  /*@__PURE__*/ S.String;

export type MeetingsUpdateMeetingByIdResponseDataAiConfigSummarizationTextFormat =
  | "plain_text"
  | "markdown";
export const MeetingsUpdateMeetingByIdResponseDataAiConfigSummarizationTextFormat =
  /*@__PURE__*/ S.String;

export interface MeetingsUpdateMeetingByIdResponseDataAiConfigSummarization {
  /** Defines the style of the summary, such as general, team meeting, or sales call. */
  summaryType?: MeetingsUpdateMeetingByIdResponseDataAiConfigSummarizationSummaryType | null;
  /** Determines the text format of the summary, such as plain text or markdown. */
  textFormat?: MeetingsUpdateMeetingByIdResponseDataAiConfigSummarizationTextFormat | null;
  /** Sets the maximum number of words in the meeting summary. */
  wordLimit?: number | null;
}
export const MeetingsUpdateMeetingByIdResponseDataAiConfigSummarization =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      summaryType: S.optional(
        S.NullOr(
          MeetingsUpdateMeetingByIdResponseDataAiConfigSummarizationSummaryType,
        ).pipe(T.Body("summary_type")),
      ),
      textFormat: S.optional(
        S.NullOr(
          MeetingsUpdateMeetingByIdResponseDataAiConfigSummarizationTextFormat,
        ).pipe(T.Body("text_format")),
      ),
      wordLimit: S.optional(S.NullOr(S.Number).pipe(T.Body("word_limit"))),
    }),
  ).annotate({
    identifier: "MeetingsUpdateMeetingByIdResponseDataAiConfigSummarization",
  }) as any as S.Schema<MeetingsUpdateMeetingByIdResponseDataAiConfigSummarization>;

export type MeetingsUpdateMeetingByIdResponseDataAiConfigTranscriptionKeywordsList =
  Array<string>;
export const MeetingsUpdateMeetingByIdResponseDataAiConfigTranscriptionKeywordsList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<MeetingsUpdateMeetingByIdResponseDataAiConfigTranscriptionKeywordsList>;

export type MeetingsUpdateMeetingByIdResponseDataAiConfigTranscriptionLanguage =
  | "en-US"
  | "en-IN"
  | "de"
  | "hi"
  | "sv"
  | "ru"
  | "pl"
  | "el"
  | "fr"
  | "nl";
export const MeetingsUpdateMeetingByIdResponseDataAiConfigTranscriptionLanguage =
  /*@__PURE__*/ S.String;

export interface MeetingsUpdateMeetingByIdResponseDataAiConfigTranscription {
  /** Adds specific terms to improve accurate detection during transcription. */
  keywords?: MeetingsUpdateMeetingByIdResponseDataAiConfigTranscriptionKeywordsList | null;
  /** Specifies the language code for transcription to ensure accurate results. */
  language?: MeetingsUpdateMeetingByIdResponseDataAiConfigTranscriptionLanguage | null;
  /** Control the inclusion of offensive language in transcriptions. */
  profanityFilter?: boolean | null;
}
export const MeetingsUpdateMeetingByIdResponseDataAiConfigTranscription =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      keywords: S.optional(
        S.NullOr(
          MeetingsUpdateMeetingByIdResponseDataAiConfigTranscriptionKeywordsList,
        ),
      ),
      language: S.optional(
        S.NullOr(
          MeetingsUpdateMeetingByIdResponseDataAiConfigTranscriptionLanguage,
        ),
      ),
      profanityFilter: S.optional(
        S.NullOr(S.Boolean).pipe(T.Body("profanity_filter")),
      ),
    }),
  ).annotate({
    identifier: "MeetingsUpdateMeetingByIdResponseDataAiConfigTranscription",
  }) as any as S.Schema<MeetingsUpdateMeetingByIdResponseDataAiConfigTranscription>;

export interface MeetingsUpdateMeetingByIdResponseDataAiConfig {
  /** Summary Config */
  summarization?: MeetingsUpdateMeetingByIdResponseDataAiConfigSummarization | null;
  /** Transcription Configurations */
  transcription?: MeetingsUpdateMeetingByIdResponseDataAiConfigTranscription | null;
}
export const MeetingsUpdateMeetingByIdResponseDataAiConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      summarization: S.optional(
        S.NullOr(MeetingsUpdateMeetingByIdResponseDataAiConfigSummarization),
      ),
      transcription: S.optional(
        S.NullOr(MeetingsUpdateMeetingByIdResponseDataAiConfigTranscription),
      ),
    }),
  ).annotate({
    identifier: "MeetingsUpdateMeetingByIdResponseDataAiConfig",
  }) as any as S.Schema<MeetingsUpdateMeetingByIdResponseDataAiConfig>;

export type MeetingsUpdateMeetingByIdResponseDataRecordingConfigAudioConfigChannel =
  | "mono"
  | "stereo";
export const MeetingsUpdateMeetingByIdResponseDataRecordingConfigAudioConfigChannel =
  /*@__PURE__*/ S.String;

export type MeetingsUpdateMeetingByIdResponseDataRecordingConfigAudioConfigCodec =
  | "MP3"
  | "AAC";
export const MeetingsUpdateMeetingByIdResponseDataRecordingConfigAudioConfigCodec =
  /*@__PURE__*/ S.String;

export interface MeetingsUpdateMeetingByIdResponseDataRecordingConfigAudioConfig {
  /** Audio signal pathway within an audio file that carries a specific sound source. */
  channel?: MeetingsUpdateMeetingByIdResponseDataRecordingConfigAudioConfigChannel | null;
  /** Codec using which the recording will be encoded. If VP8/VP9 is selected for videoConfig, changing audioConfig is not allowed. In this case, the codec in the audioConfig is automatically set to vorbis. */
  codec?: MeetingsUpdateMeetingByIdResponseDataRecordingConfigAudioConfigCodec | null;
  /** Controls whether to export audio file seperately */
  exportFile?: boolean | null;
}
export const MeetingsUpdateMeetingByIdResponseDataRecordingConfigAudioConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      channel: S.optional(
        S.NullOr(
          MeetingsUpdateMeetingByIdResponseDataRecordingConfigAudioConfigChannel,
        ),
      ),
      codec: S.optional(
        S.NullOr(
          MeetingsUpdateMeetingByIdResponseDataRecordingConfigAudioConfigCodec,
        ),
      ),
      exportFile: S.optional(S.NullOr(S.Boolean).pipe(T.Body("export_file"))),
    }),
  ).annotate({
    identifier:
      "MeetingsUpdateMeetingByIdResponseDataRecordingConfigAudioConfig",
  }) as any as S.Schema<MeetingsUpdateMeetingByIdResponseDataRecordingConfigAudioConfig>;

export type MeetingsUpdateMeetingByIdResponseDataRecordingConfigLiveStreamingConfig =
  MeetingsCreateResponseDataRecordingConfigLiveStreamingConfig;
export const MeetingsUpdateMeetingByIdResponseDataRecordingConfigLiveStreamingConfig =
  MeetingsCreateResponseDataRecordingConfigLiveStreamingConfig;

export type MeetingsUpdateMeetingByIdResponseDataRecordingConfigRealtimekitBucketConfig =
  MeetingsCreateRequestRecordingConfigRealtimekitBucketConfig;
export const MeetingsUpdateMeetingByIdResponseDataRecordingConfigRealtimekitBucketConfig =
  MeetingsCreateRequestRecordingConfigRealtimekitBucketConfig;

export type MeetingsUpdateMeetingByIdResponseDataRecordingConfigStorageConfigType =
  | "aws"
  | "azure"
  | "digitalocean"
  | "gcs"
  | "sftp";
export const MeetingsUpdateMeetingByIdResponseDataRecordingConfigStorageConfigType =
  /*@__PURE__*/ S.String;

export type MeetingsUpdateMeetingByIdResponseDataRecordingConfigStorageConfigAuthMethod =
  | "KEY"
  | "PASSWORD";
export const MeetingsUpdateMeetingByIdResponseDataRecordingConfigStorageConfigAuthMethod =
  /*@__PURE__*/ S.String;

export interface MeetingsUpdateMeetingByIdResponseDataRecordingConfigStorageConfig {
  /** Type of storage media. */
  type: MeetingsUpdateMeetingByIdResponseDataRecordingConfigStorageConfigType;
  /** Access key of the storage medium. Access key is not required for the `gcs` storage media type. */
  accessKey?: string | null;
  /** Authentication method used for "sftp" type storage medium */
  authMethod?: MeetingsUpdateMeetingByIdResponseDataRecordingConfigStorageConfigAuthMethod | null;
  /** Name of the storage medium's bucket. */
  bucket?: string | null;
  /** SSH destination server host for SFTP type storage medium */
  host?: string | null;
  /** SSH destination server password for SFTP type storage medium when auth_method is "PASSWORD". If auth_method is "KEY", this specifies the password for the ssh private key. */
  password?: string | null;
  /** Path relative to the bucket root at which the recording will be placed. */
  path?: string | null;
  /** SSH destination server port for SFTP type storage medium */
  port?: number | null;
  /** Private key used to login to destination SSH server for SFTP type storage medium, when auth_method used is "KEY" */
  privateKey?: string | null;
  /** Region of the storage medium. */
  region?: string | null;
  /** Secret key of the storage medium. Similar to `access_key`, it is only writeable by clients, not readable. */
  secret?: string | null;
  /** SSH destination server username for SFTP type storage medium */
  username?: string | null;
}
export const MeetingsUpdateMeetingByIdResponseDataRecordingConfigStorageConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: MeetingsUpdateMeetingByIdResponseDataRecordingConfigStorageConfigType,
      accessKey: S.optional(S.NullOr(S.String).pipe(T.Body("access_key"))),
      authMethod: S.optional(
        S.NullOr(
          MeetingsUpdateMeetingByIdResponseDataRecordingConfigStorageConfigAuthMethod,
        ).pipe(T.Body("auth_method")),
      ),
      bucket: S.optional(S.NullOr(S.String)),
      host: S.optional(S.NullOr(S.String)),
      password: S.optional(S.NullOr(S.String)),
      path: S.optional(S.NullOr(S.String)),
      port: S.optional(S.NullOr(S.Number)),
      privateKey: S.optional(S.NullOr(S.String).pipe(T.Body("private_key"))),
      region: S.optional(S.NullOr(S.String)),
      secret: S.optional(S.NullOr(S.String)),
      username: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier:
      "MeetingsUpdateMeetingByIdResponseDataRecordingConfigStorageConfig",
  }) as any as S.Schema<MeetingsUpdateMeetingByIdResponseDataRecordingConfigStorageConfig>;

export type MeetingsUpdateMeetingByIdResponseDataRecordingConfigVideoConfigCodec =
  | "H264"
  | "VP8";
export const MeetingsUpdateMeetingByIdResponseDataRecordingConfigVideoConfigCodec =
  /*@__PURE__*/ S.String;

export type MeetingsUpdateMeetingByIdResponseDataRecordingConfigVideoConfigWatermarkPosition =
  | "left top"
  | "right top"
  | "left bottom"
  | "right bottom";
export const MeetingsUpdateMeetingByIdResponseDataRecordingConfigVideoConfigWatermarkPosition =
  /*@__PURE__*/ S.String;

export type MeetingsUpdateMeetingByIdResponseDataRecordingConfigVideoConfigWatermarkSize =
  MeetingsCreateResponseDataRecordingConfigVideoConfigWatermarkSize;
export const MeetingsUpdateMeetingByIdResponseDataRecordingConfigVideoConfigWatermarkSize =
  MeetingsCreateResponseDataRecordingConfigVideoConfigWatermarkSize;

export interface MeetingsUpdateMeetingByIdResponseDataRecordingConfigVideoConfigWatermark {
  /** Position of the watermark */
  position?: MeetingsUpdateMeetingByIdResponseDataRecordingConfigVideoConfigWatermarkPosition | null;
  /** Size of the watermark */
  size?: MeetingsCreateResponseDataRecordingConfigVideoConfigWatermarkSize | null;
  /** URL of the watermark image */
  url?: string | null;
}
export const MeetingsUpdateMeetingByIdResponseDataRecordingConfigVideoConfigWatermark =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      position: S.optional(
        S.NullOr(
          MeetingsUpdateMeetingByIdResponseDataRecordingConfigVideoConfigWatermarkPosition,
        ),
      ),
      size: S.optional(
        S.NullOr(
          MeetingsCreateResponseDataRecordingConfigVideoConfigWatermarkSize,
        ),
      ),
      url: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier:
      "MeetingsUpdateMeetingByIdResponseDataRecordingConfigVideoConfigWatermark",
  }) as any as S.Schema<MeetingsUpdateMeetingByIdResponseDataRecordingConfigVideoConfigWatermark>;

export interface MeetingsUpdateMeetingByIdResponseDataRecordingConfigVideoConfig {
  /** Codec using which the recording will be encoded. */
  codec?: MeetingsUpdateMeetingByIdResponseDataRecordingConfigVideoConfigCodec | null;
  /** Controls whether to export video file seperately */
  exportFile?: boolean | null;
  /** Height of the recording video in pixels */
  height?: number | null;
  /** Watermark to be added to the recording */
  watermark?: MeetingsUpdateMeetingByIdResponseDataRecordingConfigVideoConfigWatermark | null;
  /** Width of the recording video in pixels */
  width?: number | null;
}
export const MeetingsUpdateMeetingByIdResponseDataRecordingConfigVideoConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      codec: S.optional(
        S.NullOr(
          MeetingsUpdateMeetingByIdResponseDataRecordingConfigVideoConfigCodec,
        ),
      ),
      exportFile: S.optional(S.NullOr(S.Boolean).pipe(T.Body("export_file"))),
      height: S.optional(S.NullOr(S.Number)),
      watermark: S.optional(
        S.NullOr(
          MeetingsUpdateMeetingByIdResponseDataRecordingConfigVideoConfigWatermark,
        ),
      ),
      width: S.optional(S.NullOr(S.Number)),
    }),
  ).annotate({
    identifier:
      "MeetingsUpdateMeetingByIdResponseDataRecordingConfigVideoConfig",
  }) as any as S.Schema<MeetingsUpdateMeetingByIdResponseDataRecordingConfigVideoConfig>;

export interface MeetingsUpdateMeetingByIdResponseDataRecordingConfig {
  /** Object containing configuration regarding the audio that is being recorded. */
  audioConfig?: MeetingsUpdateMeetingByIdResponseDataRecordingConfigAudioConfig | null;
  /** Adds a prefix to the beginning of the file name of the recording. */
  fileNamePrefix?: string | null;
  liveStreamingConfig?: MeetingsCreateResponseDataRecordingConfigLiveStreamingConfig | null;
  /** Specifies the maximum duration for recording in seconds, ranging from a minimum of 60 seconds to a maximum of 24 hours. */
  maxSeconds?: number | null;
  realtimekitBucketConfig?: MeetingsCreateRequestRecordingConfigRealtimekitBucketConfig | null;
  storageConfig?: MeetingsUpdateMeetingByIdResponseDataRecordingConfigStorageConfig | null;
  videoConfig?: MeetingsUpdateMeetingByIdResponseDataRecordingConfigVideoConfig | null;
}
export const MeetingsUpdateMeetingByIdResponseDataRecordingConfig =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      audioConfig: S.optional(
        S.NullOr(
          MeetingsUpdateMeetingByIdResponseDataRecordingConfigAudioConfig,
        ).pipe(T.Body("audio_config")),
      ),
      fileNamePrefix: S.optional(
        S.NullOr(S.String).pipe(T.Body("file_name_prefix")),
      ),
      liveStreamingConfig: S.optional(
        S.NullOr(
          MeetingsCreateResponseDataRecordingConfigLiveStreamingConfig,
        ).pipe(T.Body("live_streaming_config")),
      ),
      maxSeconds: S.optional(S.NullOr(S.Number).pipe(T.Body("max_seconds"))),
      realtimekitBucketConfig: S.optional(
        S.NullOr(
          MeetingsCreateRequestRecordingConfigRealtimekitBucketConfig,
        ).pipe(T.Body("realtimekit_bucket_config")),
      ),
      storageConfig: S.optional(
        S.NullOr(
          MeetingsUpdateMeetingByIdResponseDataRecordingConfigStorageConfig,
        ).pipe(T.Body("storage_config")),
      ),
      videoConfig: S.optional(
        S.NullOr(
          MeetingsUpdateMeetingByIdResponseDataRecordingConfigVideoConfig,
        ).pipe(T.Body("video_config")),
      ),
    }),
  ).annotate({
    identifier: "MeetingsUpdateMeetingByIdResponseDataRecordingConfig",
  }) as any as S.Schema<MeetingsUpdateMeetingByIdResponseDataRecordingConfig>;

export type MeetingsUpdateMeetingByIdResponseDataStatus = "ACTIVE" | "INACTIVE";
export const MeetingsUpdateMeetingByIdResponseDataStatus =
  /*@__PURE__*/ S.String;

export interface MeetingsUpdateMeetingByIdResponseData {
  /** ID of the meeting. */
  id: string;
  /** Timestamp the object was created at. The time is returned in ISO format. */
  createdAt: string;
  /** Timestamp the object was updated at. The time is returned in ISO format. */
  updatedAt: string;
  /** The AI Config allows you to customize the behavior of meeting transcriptions and summaries */
  aiConfig?: MeetingsUpdateMeetingByIdResponseDataAiConfig | null;
  /** Specifies if the meeting should start getting livestreamed on start. */
  liveStreamOnStart?: boolean | null;
  /** Specifies if Chat within a meeting should persist for a week. */
  persistChat?: boolean | null;
  /** Specifies if the meeting should start getting recorded as soon as someone joins the meeting. */
  recordOnStart?: boolean | null;
  /** Recording Configurations to be used for this meeting. This level of configs takes higher preference over App level configs on the RealtimeKit developer portal. */
  recordingConfig?: MeetingsUpdateMeetingByIdResponseDataRecordingConfig | null;
  /** Time in seconds, for which a session remains active, after the last participant has left the meeting. */
  sessionKeepAliveTimeInSecs?: number | null;
  /** Whether the meeting is `ACTIVE` or `INACTIVE`. Users will not be able to join an `INACTIVE` meeting. */
  status?: MeetingsUpdateMeetingByIdResponseDataStatus | null;
  /** Automatically generate summary of meetings using transcripts. Requires Transcriptions to be enabled, and can be retrieved via Webhooks or summary API. */
  summarizeOnEnd?: boolean | null;
  /** Title of the meeting. */
  title?: string | null;
  /** Automatically generate transcripts when the meeting ends. */
  transcribeOnEnd?: boolean | null;
}
export const MeetingsUpdateMeetingByIdResponseData = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.String,
      createdAt: S.String.pipe(T.Body("created_at")),
      updatedAt: S.String.pipe(T.Body("updated_at")),
      aiConfig: S.optional(
        S.NullOr(MeetingsUpdateMeetingByIdResponseDataAiConfig).pipe(
          T.Body("ai_config"),
        ),
      ),
      liveStreamOnStart: S.optional(
        S.NullOr(S.Boolean).pipe(T.Body("live_stream_on_start")),
      ),
      persistChat: S.optional(S.NullOr(S.Boolean).pipe(T.Body("persist_chat"))),
      recordOnStart: S.optional(
        S.NullOr(S.Boolean).pipe(T.Body("record_on_start")),
      ),
      recordingConfig: S.optional(
        S.NullOr(MeetingsUpdateMeetingByIdResponseDataRecordingConfig).pipe(
          T.Body("recording_config"),
        ),
      ),
      sessionKeepAliveTimeInSecs: S.optional(
        S.NullOr(S.Number).pipe(T.Body("session_keep_alive_time_in_secs")),
      ),
      status: S.optional(S.NullOr(MeetingsUpdateMeetingByIdResponseDataStatus)),
      summarizeOnEnd: S.optional(
        S.NullOr(S.Boolean).pipe(T.Body("summarize_on_end")),
      ),
      title: S.optional(S.NullOr(S.String)),
      transcribeOnEnd: S.optional(
        S.NullOr(S.Boolean).pipe(T.Body("transcribe_on_end")),
      ),
    }),
).annotate({
  identifier: "MeetingsUpdateMeetingByIdResponseData",
}) as any as S.Schema<MeetingsUpdateMeetingByIdResponseData>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface UpdateMeetingByIdMeetingResponse {
  /** Data returned by the operation */
  data?: MeetingsUpdateMeetingByIdResponseData | null;
}
export const UpdateMeetingByIdMeetingResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    data: S.optional(S.NullOr(MeetingsUpdateMeetingByIdResponseData)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "UpdateMeetingByIdMeetingResponse",
}) as any as S.Schema<UpdateMeetingByIdMeetingResponse>;

export type AddParticipantMeetingError = CloudflareOpError;
/** Adds a participant to the given meeting ID. */
export const addParticipantMeeting: API.OperationMethod<
  AddParticipantMeetingRequest,
  AddParticipantMeetingResponse,
  AddParticipantMeetingError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: AddParticipantMeetingRequest,
  output: AddParticipantMeetingResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateIndependentLivestreamLivestreamError = CloudflareOpError;
/** Creates a livestream for the given App ID and returns ingest server, stream key, and playback URL. You can pass custom input to the ingest server and stream key, and freely distribute the content using the playback URL on any player that supports HLS/LHLS. */
export const createIndependentLivestreamLivestream: API.OperationMethod<
  CreateIndependentLivestreamLivestreamRequest,
  CreateIndependentLivestreamLivestreamResponse,
  CreateIndependentLivestreamLivestreamError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateIndependentLivestreamLivestreamRequest,
  output: CreateIndependentLivestreamLivestreamResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateMeetingError = CloudflareOpError;
/** Create a meeting for the given App ID. */
export const createMeeting: API.OperationMethod<
  CreateMeetingRequest,
  CreateMeetingResponse,
  CreateMeetingError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateMeetingRequest,
  output: CreateMeetingResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreatePollActiveSessionError = CloudflareOpError;
/** Creates a new poll in an active session for the given meeting ID. */
export const createPollActiveSession: API.OperationMethod<
  CreatePollActiveSessionRequest,
  CreatePollActiveSessionResponse,
  CreatePollActiveSessionError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreatePollActiveSessionRequest,
  output: CreatePollActiveSessionResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreatePresetError =
  | RealtimeKitPresetExists
  | Forbidden
  | CloudflareOpError;
/** Creates a preset belonging to the current App */
export const createPreset: API.OperationMethod<
  CreatePresetRequest,
  CreatePresetResponse,
  CreatePresetError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreatePresetRequest,
  output: CreatePresetResponse,
  errors: [
    RealtimeKitPresetExists,
    Forbidden,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateWebhookWebhookError =
  | RealtimeKitWebhookExists
  | Forbidden
  | CloudflareOpError;
/** Adds a new webhook to an App. */
export const createWebhookWebhook: API.OperationMethod<
  CreateWebhookWebhookRequest,
  CreateWebhookWebhookResponse,
  CreateWebhookWebhookError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateWebhookWebhookRequest,
  output: CreateWebhookWebhookResponse,
  errors: [
    RealtimeKitWebhookExists,
    Forbidden,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeleteMeetingParticipantMeetingError = CloudflareOpError;
/** Deletes a participant for the given meeting and participant ID. */
export const deleteMeetingParticipantMeeting: API.OperationMethod<
  DeleteMeetingParticipantMeetingRequest,
  DeleteMeetingParticipantMeetingResponse,
  DeleteMeetingParticipantMeetingError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteMeetingParticipantMeetingRequest,
  output: DeleteMeetingParticipantMeetingResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeletePresetError =
  | RealtimeKitPresetNotFound
  | Forbidden
  | CloudflareOpError;
/** Deletes a preset using the provided preset ID */
export const deletePreset: API.OperationMethod<
  DeletePresetRequest,
  DeletePresetResponse,
  DeletePresetError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeletePresetRequest,
  output: DeletePresetResponse,
  errors: [
    RealtimeKitPresetNotFound,
    Forbidden,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeleteWebhookWebhookError =
  | RealtimeKitWebhookNotFound
  | Forbidden
  | CloudflareOpError;
/** Removes a webhook for the given webhook ID. */
export const deleteWebhookWebhook: API.OperationMethod<
  DeleteWebhookWebhookRequest,
  DeleteWebhookWebhookResponse,
  DeleteWebhookWebhookError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteWebhookWebhookRequest,
  output: DeleteWebhookWebhookResponse,
  errors: [
    RealtimeKitWebhookNotFound,
    Forbidden,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type EditParticipantMeetingError = CloudflareOpError;
/** Updates a participant's details for the given meeting and participant ID. */
export const editParticipantMeeting: API.OperationMethod<
  EditParticipantMeetingRequest,
  EditParticipantMeetingResponse,
  EditParticipantMeetingError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: EditParticipantMeetingRequest,
  output: EditParticipantMeetingResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type EditWebhookWebhookError = CloudflareOpError;
/** Edits the webhook details for the given webhook ID. */
export const editWebhookWebhook: API.OperationMethod<
  EditWebhookWebhookRequest,
  EditWebhookWebhookResponse,
  EditWebhookWebhookError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: EditWebhookWebhookRequest,
  output: EditWebhookWebhookResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GenerateSummaryOfTranscriptsSessionError = CloudflareOpError;
/** Trigger Summary generation of Transcripts for the session ID. */
export const generateSummaryOfTranscriptsSession: API.OperationMethod<
  GenerateSummaryOfTranscriptsSessionRequest,
  GenerateSummaryOfTranscriptsSessionResponse,
  GenerateSummaryOfTranscriptsSessionError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GenerateSummaryOfTranscriptsSessionRequest,
  output: GenerateSummaryOfTranscriptsSessionResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetActiveLivestreamsForLivestreamIdLivestreamError =
  CloudflareOpError;
/** Returns details of all active livestreams for the given livestream ID. Retreive the livestream ID using the `Start livestreaming a meeting` API. */
export const getActiveLivestreamsForLivestreamIdLivestream: API.OperationMethod<
  GetActiveLivestreamsForLivestreamIdLivestreamRequest,
  GetActiveLivestreamsForLivestreamIdLivestreamResponse,
  GetActiveLivestreamsForLivestreamIdLivestreamError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetActiveLivestreamsForLivestreamIdLivestreamRequest,
  output: GetActiveLivestreamsForLivestreamIdLivestreamResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetActiveRecordingsRecordingError = CloudflareOpError;
/** Returns the active recording details for the given meeting ID. */
export const getActiveRecordingsRecording: API.OperationMethod<
  GetActiveRecordingsRecordingRequest,
  GetActiveRecordingsRecordingResponse,
  GetActiveRecordingsRecordingError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetActiveRecordingsRecordingRequest,
  output: GetActiveRecordingsRecordingResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetActiveSessionActiveSessionError = CloudflareOpError;
/** Returns details of an ongoing active session for the given meeting ID. */
export const getActiveSessionActiveSession: API.OperationMethod<
  GetActiveSessionActiveSessionRequest,
  GetActiveSessionActiveSessionResponse,
  GetActiveSessionActiveSessionError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetActiveSessionActiveSessionRequest,
  output: GetActiveSessionActiveSessionResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetAllLivestreamsLivestreamError = CloudflareOpError;
/** Returns details of livestreams associated with the given App ID. It includes livestreams created by your App and RealtimeKit meetings that are livestreamed by your App. If you only want details of livestreams created by your App and not RealtimeKit meetings, you can use the `exclude_meetings` query parameter. */
export const getAllLivestreamsLivestream: API.OperationMethod<
  GetAllLivestreamsLivestreamRequest,
  GetAllLivestreamsLivestreamResponse,
  GetAllLivestreamsLivestreamError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetAllLivestreamsLivestreamRequest,
  output: GetAllLivestreamsLivestreamResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetAppError = Forbidden | CloudflareOpError;
/** Fetch all apps for your account */
export const getApp: API.OperationMethod<
  GetAppRequest,
  GetAppResponse,
  GetAppError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetAppRequest,
  output: GetAppResponse,
  errors: [Forbidden, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetLivestreamAnalyticsCompleteLivestreamError = CloudflareOpError;
/** Returns livestream analytics for the specified time range. */
export const getLivestreamAnalyticsCompleteLivestream: API.OperationMethod<
  GetLivestreamAnalyticsCompleteLivestreamRequest,
  GetLivestreamAnalyticsCompleteLivestreamResponse,
  GetLivestreamAnalyticsCompleteLivestreamError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetLivestreamAnalyticsCompleteLivestreamRequest,
  output: GetLivestreamAnalyticsCompleteLivestreamResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetLivestreamAnalyticsDaywiseLivestreamError = CloudflareOpError;
/** Returns day-wise livestream analytics for the specified time range. */
export const getLivestreamAnalyticsDaywiseLivestream: API.OperationMethod<
  GetLivestreamAnalyticsDaywiseLivestreamRequest,
  GetLivestreamAnalyticsDaywiseLivestreamResponse,
  GetLivestreamAnalyticsDaywiseLivestreamError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetLivestreamAnalyticsDaywiseLivestreamRequest,
  output: GetLivestreamAnalyticsDaywiseLivestreamResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetLivestreamSessionDetailsForSessionIdLivestreamError =
  CloudflareOpError;
/** Returns livestream session details for the given livestream session ID. Retrieve the `livestream_session_id`using the `Fetch livestream session details using a session ID` API. */
export const getLivestreamSessionDetailsForSessionIdLivestream: API.OperationMethod<
  GetLivestreamSessionDetailsForSessionIdLivestreamRequest,
  GetLivestreamSessionDetailsForSessionIdLivestreamResponse,
  GetLivestreamSessionDetailsForSessionIdLivestreamError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetLivestreamSessionDetailsForSessionIdLivestreamRequest,
  output: GetLivestreamSessionDetailsForSessionIdLivestreamResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetLivestreamSessionForLivestreamIdLivestreamError =
  CloudflareOpError;
/** Returns details of a livestream with sessions for the given livestream ID. Retreive the livestream ID using the `Start livestreaming a meeting` API. */
export const getLivestreamSessionForLivestreamIdLivestream: API.OperationMethod<
  GetLivestreamSessionForLivestreamIdLivestreamRequest,
  GetLivestreamSessionForLivestreamIdLivestreamResponse,
  GetLivestreamSessionForLivestreamIdLivestreamError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetLivestreamSessionForLivestreamIdLivestreamRequest,
  output: GetLivestreamSessionForLivestreamIdLivestreamResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetMeetingError = CloudflareOpError;
/** Returns all meetings for the given App ID. */
export const getMeeting: API.OperationMethod<
  GetMeetingRequest,
  GetMeetingResponse,
  GetMeetingError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetMeetingRequest,
  output: GetMeetingResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetMeetingActiveLivestreamsLivestreamError = CloudflareOpError;
/** Returns details of all active livestreams for the given meeting ID. */
export const getMeetingActiveLivestreamsLivestream: API.OperationMethod<
  GetMeetingActiveLivestreamsLivestreamRequest,
  GetMeetingActiveLivestreamsLivestreamResponse,
  GetMeetingActiveLivestreamsLivestreamError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetMeetingActiveLivestreamsLivestreamRequest,
  output: GetMeetingActiveLivestreamsLivestreamResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetMeetingByIdMeetingError = CloudflareOpError;
/** Returns a meeting details in an App for the given meeting ID. */
export const getMeetingByIdMeeting: API.OperationMethod<
  GetMeetingByIdMeetingRequest,
  GetMeetingByIdMeetingResponse,
  GetMeetingByIdMeetingError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetMeetingByIdMeetingRequest,
  output: GetMeetingByIdMeetingResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetMeetingParticipantMeetingError = CloudflareOpError;
/** Returns a participant details for the given meeting and participant ID. */
export const getMeetingParticipantMeeting: API.OperationMethod<
  GetMeetingParticipantMeetingRequest,
  GetMeetingParticipantMeetingResponse,
  GetMeetingParticipantMeetingError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetMeetingParticipantMeetingRequest,
  output: GetMeetingParticipantMeetingResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetMeetingParticipantsMeetingError = CloudflareOpError;
/** Returns all participants detail for the given meeting ID. */
export const getMeetingParticipantsMeeting: API.OperationMethod<
  GetMeetingParticipantsMeetingRequest,
  GetMeetingParticipantsMeetingResponse,
  GetMeetingParticipantsMeetingError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetMeetingParticipantsMeetingRequest,
  output: GetMeetingParticipantsMeetingResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetOneRecordingRecordingError = CloudflareOpError;
/** Returns details of a recording for the given recording ID. */
export const getOneRecordingRecording: API.OperationMethod<
  GetOneRecordingRecordingRequest,
  GetOneRecordingRecordingResponse,
  GetOneRecordingRecordingError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetOneRecordingRecordingRequest,
  output: GetOneRecordingRecordingResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetOrgAnalyticsAnalyticError = CloudflareOpError;
/** Returns day-wise session and recording analytics data of an App for the specified time range start_date to end_date. If start_date and end_date are not provided, the default time range is set from 30 days ago to the current date. */
export const getOrgAnalyticsAnalytic: API.OperationMethod<
  GetOrgAnalyticsAnalyticRequest,
  GetOrgAnalyticsAnalyticResponse,
  GetOrgAnalyticsAnalyticError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetOrgAnalyticsAnalyticRequest,
  output: GetOrgAnalyticsAnalyticResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetParticipantDataFromPeerIdSessionError = CloudflareOpError;
/** Returns participant details for the given peer ID along with call statistics. */
export const getParticipantDataFromPeerIdSession: API.OperationMethod<
  GetParticipantDataFromPeerIdSessionRequest,
  GetParticipantDataFromPeerIdSessionResponse,
  GetParticipantDataFromPeerIdSessionError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetParticipantDataFromPeerIdSessionRequest,
  output: GetParticipantDataFromPeerIdSessionResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetPresetError = Forbidden | CloudflareOpError;
/** Fetches all the presets belonging to an App. */
export const getPreset: API.OperationMethod<
  GetPresetRequest,
  GetPresetResponse,
  GetPresetError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetPresetRequest,
  output: GetPresetResponse,
  errors: [Forbidden, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetPresetByIdPresetError =
  | RealtimeKitPresetNotFound
  | Forbidden
  | CloudflareOpError;
/** Fetches details of a preset using the provided preset ID */
export const getPresetByIdPreset: API.OperationMethod<
  GetPresetByIdPresetRequest,
  GetPresetByIdPresetResponse,
  GetPresetByIdPresetError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetPresetByIdPresetRequest,
  output: GetPresetByIdPresetResponse,
  errors: [
    RealtimeKitPresetNotFound,
    Forbidden,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetRecordingsRecordingError = CloudflareOpError;
/** Returns all recordings for an App. If the `meeting_id` parameter is passed, returns all recordings for the given meeting ID. */
export const getRecordingsRecording: API.OperationMethod<
  GetRecordingsRecordingRequest,
  GetRecordingsRecordingResponse,
  GetRecordingsRecordingError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetRecordingsRecordingRequest,
  output: GetRecordingsRecordingResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetSessionChatSessionError = CloudflareOpError;
/** Returns a URL to download all chat messages of the session ID in CSV format. */
export const getSessionChatSession: API.OperationMethod<
  GetSessionChatSessionRequest,
  GetSessionChatSessionResponse,
  GetSessionChatSessionError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetSessionChatSessionRequest,
  output: GetSessionChatSessionResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetSessionDetailsSessionError = CloudflareOpError;
/** Returns data of the given session ID including recording details. */
export const getSessionDetailsSession: API.OperationMethod<
  GetSessionDetailsSessionRequest,
  GetSessionDetailsSessionResponse,
  GetSessionDetailsSessionError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetSessionDetailsSessionRequest,
  output: GetSessionDetailsSessionResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetSessionParticipantDetailsSessionError = CloudflareOpError;
/** Returns details of the given participant ID along with call statistics for the given session ID. */
export const getSessionParticipantDetailsSession: API.OperationMethod<
  GetSessionParticipantDetailsSessionRequest,
  GetSessionParticipantDetailsSessionResponse,
  GetSessionParticipantDetailsSessionError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetSessionParticipantDetailsSessionRequest,
  output: GetSessionParticipantDetailsSessionResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetSessionParticipantsSessionError = CloudflareOpError;
/** Returns a list of participants for the given session ID. */
export const getSessionParticipantsSession: API.OperationMethod<
  GetSessionParticipantsSessionRequest,
  GetSessionParticipantsSessionResponse,
  GetSessionParticipantsSessionError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetSessionParticipantsSessionRequest,
  output: GetSessionParticipantsSessionResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetSessionsSessionError = CloudflareOpError;
/** Returns details of all sessions of an App. */
export const getSessionsSession: API.OperationMethod<
  GetSessionsSessionRequest,
  GetSessionsSessionResponse,
  GetSessionsSessionError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetSessionsSessionRequest,
  output: GetSessionsSessionResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetSessionSummarySessionError = CloudflareOpError;
/** Returns a Summary URL to download the Summary of Transcripts for the session ID as plain text. */
export const getSessionSummarySession: API.OperationMethod<
  GetSessionSummarySessionRequest,
  GetSessionSummarySessionResponse,
  GetSessionSummarySessionError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetSessionSummarySessionRequest,
  output: GetSessionSummarySessionResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetSessionTranscriptsSessionError = CloudflareOpError;
/** Returns a URL to download the transcript for the session ID in CSV format. */
export const getSessionTranscriptsSession: API.OperationMethod<
  GetSessionTranscriptsSessionRequest,
  GetSessionTranscriptsSessionResponse,
  GetSessionTranscriptsSessionError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetSessionTranscriptsSessionRequest,
  output: GetSessionTranscriptsSessionResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetWebhookByIdWebhookError =
  | RealtimeKitWebhookNotFound
  | Forbidden
  | CloudflareOpError;
/** Returns webhook details for the given webhook ID. */
export const getWebhookByIdWebhook: API.OperationMethod<
  GetWebhookByIdWebhookRequest,
  GetWebhookByIdWebhookResponse,
  GetWebhookByIdWebhookError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetWebhookByIdWebhookRequest,
  output: GetWebhookByIdWebhookResponse,
  errors: [
    RealtimeKitWebhookNotFound,
    Forbidden,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetWebhooksWebhookError =
  | RealtimeKitWebhookNotFound
  | Forbidden
  | CloudflareOpError;
/** Returns details of all webhooks for an App. */
export const getWebhooksWebhook: API.OperationMethod<
  GetWebhooksWebhookRequest,
  GetWebhooksWebhookResponse,
  GetWebhooksWebhookError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetWebhooksWebhookRequest,
  output: GetWebhooksWebhookResponse,
  errors: [
    RealtimeKitWebhookNotFound,
    Forbidden,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type KickAllParticipantsActiveSessionError = CloudflareOpError;
/** Kicks all participants from an active session for the given meeting ID. */
export const kickAllParticipantsActiveSession: API.OperationMethod<
  KickAllParticipantsActiveSessionRequest,
  KickAllParticipantsActiveSessionResponse,
  KickAllParticipantsActiveSessionError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: KickAllParticipantsActiveSessionRequest,
  output: KickAllParticipantsActiveSessionResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type KickParticipantsActiveSessionError = CloudflareOpError;
/** Kicks one or more participants from an active session using user ID or custom participant ID. */
export const kickParticipantsActiveSession: API.OperationMethod<
  KickParticipantsActiveSessionRequest,
  KickParticipantsActiveSessionResponse,
  KickParticipantsActiveSessionError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: KickParticipantsActiveSessionRequest,
  output: KickParticipantsActiveSessionResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type LivestreamsGetOrgAnalyticsError = CloudflareOpError;
/** Returns day-wise session and recording analytics data of an App for the specified time range start_date to end_date. If start_date and end_date are not provided, the default time range is set from 30 days ago to the current date. */
export const livestreamsGetOrgAnalytics: API.OperationMethod<
  LivestreamsGetOrgAnalyticsRequest,
  LivestreamsGetOrgAnalyticsResponse,
  LivestreamsGetOrgAnalyticsError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: LivestreamsGetOrgAnalyticsRequest,
  output: LivestreamsGetOrgAnalyticsResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type PatchPresetError =
  | RealtimeKitPresetNotFound
  | Forbidden
  | CloudflareOpError;
/** Update a preset by the provided preset ID */
export const patchPreset: API.OperationMethod<
  PatchPresetRequest,
  PatchPresetResponse,
  PatchPresetError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: PatchPresetRequest,
  output: PatchPresetResponse,
  errors: [
    RealtimeKitPresetNotFound,
    Forbidden,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type PauseResumeStopRecordingRecordingError = CloudflareOpError;
/** Pause/Resume/Stop a given recording ID. */
export const pauseResumeStopRecordingRecording: API.OperationMethod<
  PauseResumeStopRecordingRecordingRequest,
  PauseResumeStopRecordingRecordingResponse,
  PauseResumeStopRecordingRecordingError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: PauseResumeStopRecordingRecordingRequest,
  output: PauseResumeStopRecordingRecordingResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type PostAppError = Forbidden | CloudflareOpError;
/** Create new app for your account */
export const postApp: API.OperationMethod<
  PostAppRequest,
  PostAppResponse,
  PostAppError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: PostAppRequest,
  output: PostAppResponse,
  errors: [Forbidden, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type RefreshParticipantTokenMeetingError = CloudflareOpError;
/** Regenerates participant's authentication token for the given meeting and participant ID. */
export const refreshParticipantTokenMeeting: API.OperationMethod<
  RefreshParticipantTokenMeetingRequest,
  RefreshParticipantTokenMeetingResponse,
  RefreshParticipantTokenMeetingError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: RefreshParticipantTokenMeetingRequest,
  output: RefreshParticipantTokenMeetingResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type ReplaceMeetingByIdMeetingError = CloudflareOpError;
/** Replaces all the details for the given meeting ID. */
export const replaceMeetingByIdMeeting: API.OperationMethod<
  ReplaceMeetingByIdMeetingRequest,
  ReplaceMeetingByIdMeetingResponse,
  ReplaceMeetingByIdMeetingError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: ReplaceMeetingByIdMeetingRequest,
  output: ReplaceMeetingByIdMeetingResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type ReplaceWebhookWebhookError =
  | RealtimeKitWebhookNotFound
  | Forbidden
  | CloudflareOpError;
/** Replace all details for the given webhook ID. */
export const replaceWebhookWebhook: API.OperationMethod<
  ReplaceWebhookWebhookRequest,
  ReplaceWebhookWebhookResponse,
  ReplaceWebhookWebhookError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: ReplaceWebhookWebhookRequest,
  output: ReplaceWebhookWebhookResponse,
  errors: [
    RealtimeKitWebhookNotFound,
    Forbidden,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type StartLivestreamingAMeetingLivestreamError = CloudflareOpError;
/** Starts livestream of a meeting associated with the given meeting ID. Retreive the meeting ID using the `Create a meeting` API. */
export const startLivestreamingAMeetingLivestream: API.OperationMethod<
  StartLivestreamingAMeetingLivestreamRequest,
  StartLivestreamingAMeetingLivestreamResponse,
  StartLivestreamingAMeetingLivestreamError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: StartLivestreamingAMeetingLivestreamRequest,
  output: StartLivestreamingAMeetingLivestreamResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type StartRecordingsRecordingError = CloudflareOpError;
/** Starts recording a meeting. The meeting can be started by an App admin directly, or a participant with permissions to start a recording, based on the type of authorization used. */
export const startRecordingsRecording: API.OperationMethod<
  StartRecordingsRecordingRequest,
  StartRecordingsRecordingResponse,
  StartRecordingsRecordingError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: StartRecordingsRecordingRequest,
  output: StartRecordingsRecordingResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type StartTrackRecordingRecordingError = CloudflareOpError;
/** Starts track recording for a meeting. Track recording currently records separate participant audio tracks as WebM files in the RealtimeKit bucket. Video track recording is in development. For more information, refer to [Track recording](/realtime/realtimekit/recording-guide/track-recording/). */
export const startTrackRecordingRecording: API.OperationMethod<
  StartTrackRecordingRecordingRequest,
  StartTrackRecordingRecordingResponse,
  StartTrackRecordingRecordingError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: StartTrackRecordingRecordingRequest,
  output: StartTrackRecordingRecordingResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type StopLivestreamingAMeetingLivestreamError = CloudflareOpError;
/** Stops the active livestream of a meeting associated with the given meeting ID. Retreive the meeting ID using the `Create a meeting` API. */
export const stopLivestreamingAMeetingLivestream: API.OperationMethod<
  StopLivestreamingAMeetingLivestreamRequest,
  StopLivestreamingAMeetingLivestreamResponse,
  StopLivestreamingAMeetingLivestreamError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: StopLivestreamingAMeetingLivestreamRequest,
  output: StopLivestreamingAMeetingLivestreamResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type UpdateMeetingByIdMeetingError = CloudflareOpError;
/** Updates a meeting in an App for the given meeting ID. */
export const updateMeetingByIdMeeting: API.OperationMethod<
  UpdateMeetingByIdMeetingRequest,
  UpdateMeetingByIdMeetingResponse,
  UpdateMeetingByIdMeetingError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: UpdateMeetingByIdMeetingRequest,
  output: UpdateMeetingByIdMeetingResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

// Alias of getOrgAnalyticsAnalytic (same route, alternate export name upstream).
export const getOrgAnalyticsLivestream = getOrgAnalyticsAnalytic;
export type GetOrgAnalyticsLivestreamRequest = GetOrgAnalyticsAnalyticRequest;
export type GetOrgAnalyticsLivestreamResponse = GetOrgAnalyticsAnalyticResponse;
export type GetOrgAnalyticsLivestreamError = GetOrgAnalyticsAnalyticError;