@arbidocs/client 0.4.110 → 0.4.112

package/dist/index.d.ts

@@ -4073,7 +4073,8 @@ interface paths {
          * Create Call
          * @description Create a call: a chat's call (``chat_ext_id``), a thread call (``thread_ext_id``, get-or-create), or a
          *     contacts / calendar-event call. Invitees must be invitable (``403 not_a_contact`` / ``workspace_locked``, agents
-         *     ``422 agent_not_allowed``).
+         *     ``422 agent_not_allowed``). A webinar (``mode = 'webinar'``) is a contacts / calendar call only (``422
+         *     webinar_not_allowed_here`` with a chat or thread); its invitees carry their roles (default attendee).
          */
         post: operations['create_call'];
         delete?: never;
@@ -4108,7 +4109,9 @@ interface paths {
         /**
          * Update Call
          * @description Creator only: title, lock, join policy, and link reset (new key, old links stop working). ``sealed_keys``
-         *     re-seals K for existing invitees only; new people are added by ringing.
+         *     re-seals K for existing invitees only; new people are added by ringing. ``roles`` changes a webinar's team /
+         *     audience roles (existing invitees only; it applies from their next join, and the room is told to refetch the
+         *     webinar state).
          */
         patch: operations['update_call'];
         trace?: never;
@@ -4135,6 +4138,8 @@ interface paths {
          *     * Otherwise the body creates an E2E ``meeting`` chat at epoch 1 (members: usually the creator and the
          *       invitees). A member who is not yet an invitee needs ``call_sealed_key`` (K sealed to them) and must be
          *       invitable; they become an invitee so every member can always join.
+         *     * A webinar's meeting chat is its team's (host, co-hosts, panelists): only they open it, and every member must be
+         *       one of them (``422 attendee_not_member``).
          */
         post: operations['get_or_create_call_chat'];
         delete?: never;
@@ -4159,6 +4164,10 @@ interface paths {
          *     ``invite_token`` (a personal invite link's ``i=``): valid for this call and sent to the caller's own e-mail, it
          *     admits the caller at once — no lobby, no link version — and makes them an invitee. A forwarded link without the
          *     token, or another account presenting it, follows the normal rules.
+         *
+         *     A webinar mints the grant of the caller's role and stage state (on stage: publish, data, visible; the audience:
+         *     hidden, no publish, data only when the chat is open to everyone) with ``{"webinar_role": …}`` metadata; an
+         *     attendee before go-live gets 409 ``webinar_not_live``.
          */
         post: operations['create_call_token'];
         delete?: never;
@@ -4180,7 +4189,7 @@ interface paths {
          * Ring Call
          * @description Ring users into the call. Each gets the call key sealed to them and becomes an invitee. Targets must be
          *     invitable: your contacts, members of the call's chat or its invitees; for a thread call members of its
-         *     workspace; never an agent.
+         *     workspace; never an agent. In a webinar only its moderators ring (403 ``moderator_only``).
          */
         post: operations['ring_call'];
         delete?: never;
@@ -4222,7 +4231,8 @@ interface paths {
          * Knock Call
          * @description Ask to join (signed in). Admitted at once when the join policy lets you in directly (a host always;
          *     ``signed_in`` / ``open`` with the current link); otherwise pending until a host admits or denies it (poll
-         *     ``GET .../knock/{id}``). A thread call takes only members of its workspace.
+         *     ``GET .../knock/{id}``). A thread call takes only members of its workspace. A webinar's attendee cannot knock
+         *     before go-live (409 ``webinar_not_live``).
          */
         post: operations['knock_call'];
         delete?: never;
@@ -4247,7 +4257,8 @@ interface paths {
         /**
          * Resolve Call Knock
          * @description Admit or deny a knock. The creator or an invitee only (for a thread call, while a member of its workspace;
-         *     the knocker must still be one too).
+         *     the knocker must still be one too); in a webinar its moderators, and only once it is live (409
+         *     ``webinar_not_live``: a knocker is an attendee).
          */
         post: operations['resolve_call_knock'];
         delete?: never;
@@ -4391,8 +4402,9 @@ interface paths {
          * @description Transcribe one segment of your own microphone. The speaker is you (attribution by origin).
          *
          *     You must be admissible to the call (the ``POST /token`` rule; for a thread call a member of its workspace, any
-         *     role) or already in the room. 410 cancelled, 403 not admissible, 409 ``transcription_off``, 429 over 30 segments
-         *     a minute, 413 over 2 MB, 400 empty, 503 no transcriber, 502 the transcriber failed. Billed by the usual rule:
+         *     role) or already in the room; in a webinar, on stage (403 ``not_on_stage``: only the stage is transcribed). 410
+         *     cancelled, 403 not admissible, 409 ``transcription_off``, 429 over 30 segments a minute, 413 over 2 MB, 400
+         *     empty, 503 no transcriber, 502 the transcriber failed. Billed by the usual rule:
          *     a thread call to its workspace's project, any other call to your own default project.
          *
          *     The final open segment survives the switch-off: after the host turns transcription off, or the room finishes, a
@@ -4510,7 +4522,8 @@ interface paths {
          *     parts tell you where you are).
          *
          *     * ``speaker``: your own microphone. You must be admissible to the call (the ``POST /token`` rule; for a thread
-         *       call a member of its workspace, any role — the workspace guest role included) or already in the room.
+         *       call a member of its workspace, any role — the workspace guest role included) or already in the room; in a
+         *       webinar, on stage (403 ``not_on_stage``).
          *     * ``composite``: the host's view, host only, ``audio_video`` recordings only (422 ``composite_needs_video``).
          *
          *     409 ``recording_stopped`` once the recording has stopped.
@@ -4678,6 +4691,158 @@ interface paths {
         patch?: never;
         trace?: never;
     };
+    '/v1/calls/{call_ext_id}/webinar': {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get Call Webinar
+         * @description The webinar's state and the caller's role / stage state; the moderators also get the hand queue (oldest
+         *     first) and everyone in the room (hidden audience included). A link holder who would have to knock gets the
+         *     state too (the "Starting soon" poll).
+         */
+        get: operations['get_call_webinar'];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        /**
+         * Update Call Webinar
+         * @description Moderators (403 ``moderator_only``): ``live`` true opens the stage; false ends the webinar for everyone (the
+         *     room is closed; its session state is cleared). ``chat`` (panelists | everyone) is applied live to the audience.
+         *     Changes are announced (``arbi.webinar {type: "state"}``, WS ``call.webinar``).
+         */
+        patch: operations['update_call_webinar'];
+        trace?: never;
+    };
+    '/v1/calls/{call_ext_id}/webinar/hand': {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Raise Call Webinar Hand
+         * @description Raise or lower your hand (an audience member: 409 ``on_stage`` otherwise). The moderators in the room get the
+         *     queue (``arbi.webinar {type: "hands", hands}``).
+         */
+        post: operations['raise_call_webinar_hand'];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    '/v1/calls/{call_ext_id}/webinar/stage/{identity}': {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Promote Call Webinar Participant
+         * @description Moderators: bring someone in the room on stage — publish and visible at once (404 not in the room). Their
+         *     hand is lowered; they get ``arbi.webinar {type: "promoted"}``. A reconnect keeps them on stage this session.
+         */
+        post: operations['promote_call_webinar_participant'];
+        /**
+         * Demote Call Webinar Participant
+         * @description Take someone off the stage: a moderator, or yourself (step down; 403 ``moderator_only`` otherwise). The host
+         *     cannot be demoted (403 ``host_not_demotable``).
+         *
+         *     Their publish permission is revoked while they stay visible (LiveKit unpublishes their tracks), they get
+         *     ``arbi.webinar {type: "demoted"}``, then they are removed from the room (the others see them leave). The client
+         *     rejoins at once: its new token is hidden, because this session's stage state now says so.
+         */
+        delete: operations['demote_call_webinar_participant'];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    '/v1/calls/{call_ext_id}/webinar/questions': {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List Call Webinar Questions
+         * @description The webinar's questions, oldest first (any admitted participant). Dismissed questions are shown to the team
+         *     and to their asker only; ``asker_ext_id`` likewise (attendees never learn who else attends).
+         */
+        get: operations['list_call_webinar_questions'];
+        put?: never;
+        /**
+         * Ask Call Webinar Question
+         * @description Ask a question (any admitted participant; ``body`` is ciphertext under the call key). 429 over 10 a minute.
+         */
+        post: operations['ask_call_webinar_question'];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    '/v1/calls/{call_ext_id}/webinar/questions/{question_ext_id}/vote': {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Vote Call Webinar Question
+         * @description Upvote (``up`` true) or withdraw your vote — one per user, idempotent. Not your own question (403
+         *     ``own_question``), not a dismissed one (409 ``question_dismissed``).
+         */
+        post: operations['vote_call_webinar_question'];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    '/v1/calls/{call_ext_id}/webinar/questions/{question_ext_id}': {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post?: never;
+        /**
+         * Delete Call Webinar Question
+         * @description Delete a question: its asker while it is open (409 ``question_not_open`` after), or the team (403
+         *     ``team_only`` for anyone else).
+         */
+        delete: operations['delete_call_webinar_question'];
+        options?: never;
+        head?: never;
+        /**
+         * Update Call Webinar Question
+         * @description The team (403 ``team_only``): ``status`` (``answering`` = being answered live, ``answered``, ``dismissed``,
+         *     ``open``) and/or a text ``answer`` (ciphertext under the call key; null clears it). Answering records who and
+         *     when.
+         */
+        patch: operations['update_call_webinar_question'];
+        trace?: never;
+    };
     '/v1/chats/attachments': {
         parameters: {
             query?: never;
@@ -4845,7 +5010,8 @@ interface paths {
         };
         /**
          * List Chat Messages
-         * @description Messages, newest first. Page backwards with ``before`` = the oldest message you have.
+         * @description Messages, newest first; deleted ones are tombstones (``deleted``; no content or attachments). Page
+         *     backwards with ``before`` = the oldest message you have.
          */
         get: operations['list_chat_messages'];
         put?: never;
@@ -4882,7 +5048,10 @@ interface paths {
         post?: never;
         /**
          * Delete Chat Message
-         * @description Delete one of your own messages (404 for anyone else's). Its attachments go when nothing links them.
+         * @description Delete one of your own messages (404 for anyone else's). It stays in place as a tombstone (``deleted``, no
+         *     ``content`` or ``attachments``), so every member sees "Message deleted", live (``chat.updated`` carrying the
+         *     tombstone) and after a reload. Its attachments go when nothing else links them. Deleting a tombstone again is
+         *     a no-op (204).
          */
         delete: operations['delete_chat_message'];
         options?: never;
@@ -9918,6 +10087,10 @@ interface components {
          *
          *     Invitees must be invitable: never an agent; for a thread call members of its workspace; otherwise the caller's
          *     contacts or members of the chat.
+         *
+         *     ``mode = 'webinar'`` (docs/webinars-plan.md): a contacts / calendar call only (``422 webinar_not_allowed_here``
+         *     with a chat or thread); each invitee may carry a ``role`` (cohost | panelist | attendee, default attendee).
+         *     ``role`` on an ordinary call is a validation error.
          */
         CallCreate: {
             /** Title */
@@ -9932,6 +10105,12 @@ interface components {
             creator_sealed_key: string;
             /** Invitees */
             invitees?: components['schemas']['CallInviteeIn'][];
+            /**
+             * Mode
+             * @default call
+             * @enum {string}
+             */
+            mode: 'call' | 'webinar';
         };
         /**
          * CallDeclinedMessage
@@ -10017,6 +10196,8 @@ interface components {
             user_ext_id: string;
             /** Sealed Key */
             sealed_key: string;
+            /** Role */
+            role?: ('cohost' | 'panelist' | 'attendee') | null;
         };
         /** CallInviteeResponse */
         CallInviteeResponse: {
@@ -10030,6 +10211,8 @@ interface components {
             display_name: string;
             /** Encryption Public Key */
             encryption_public_key?: string | null;
+            /** Role */
+            role?: ('cohost' | 'panelist' | 'attendee') | null;
         };
         /** CallKnockDecision */
         CallKnockDecision: {
@@ -10111,6 +10294,72 @@ interface components {
             identity: string;
             /** Name */
             name: string;
+            /**
+             * Hidden
+             * @default false
+             */
+            hidden: boolean;
+        };
+        /** CallQuestionCreate */
+        CallQuestionCreate: {
+            /** Body */
+            body: string;
+        };
+        /** CallQuestionResponse */
+        CallQuestionResponse: {
+            /** External Id */
+            external_id: string;
+            /** Body */
+            body: string;
+            /**
+             * Status
+             * @enum {string}
+             */
+            status: 'open' | 'answering' | 'answered' | 'dismissed';
+            /** Answer */
+            answer?: string | null;
+            /** Answered By Ext Id */
+            answered_by_ext_id?: string | null;
+            /** Answered At */
+            answered_at?: string | null;
+            /**
+             * Vote Count
+             * @default 0
+             */
+            vote_count: number;
+            /**
+             * Voted
+             * @default false
+             */
+            voted: boolean;
+            /** Asker Ext Id */
+            asker_ext_id?: string | null;
+            /**
+             * Mine
+             * @default false
+             */
+            mine: boolean;
+            /**
+             * Created At
+             * Format: date-time
+             */
+            created_at: string;
+        };
+        /**
+         * CallQuestionUpdate
+         * @description Team only. ``answer`` (ciphertext under K, null clears it) answers in text; ``status`` answering marks the
+         *     question as being answered live.
+         */
+        CallQuestionUpdate: {
+            /** Status */
+            status?: ('open' | 'answering' | 'answered' | 'dismissed') | null;
+            /** Answer */
+            answer?: string | null;
+        };
+        /** CallQuestionVote */
+        CallQuestionVote: {
+            /** Up */
+            up: boolean;
         };
         /**
          * CallRecordingPartCreate
@@ -10332,7 +10581,8 @@ interface components {
         /**
          * CallResponse
          * @description A call. A viewer who is neither a host nor (for a thread call) a member of the locked workspace gets the
-         *     public stub: no title, context, invitees, participants or keys.
+         *     public stub: no title, context, invitees, participants or keys. In a webinar an attendee sees only the team
+         *     among ``invitees`` and only the visible (stage) people among ``participants``.
          */
         CallResponse: {
             /** External Id */
@@ -10409,6 +10659,13 @@ interface components {
             recording?: components['schemas']['CallRecordingState'] | null;
             /** Link Path */
             link_path: string;
+            /**
+             * Mode
+             * @default call
+             * @enum {string}
+             */
+            mode: 'call' | 'webinar';
+            webinar?: components['schemas']['CallWebinarSummary'] | null;
         };
         /**
          * CallRingRequest
@@ -10572,6 +10829,9 @@ interface components {
         /**
          * CallUpdate
          * @description Creator only. ``reset_link`` needs the new K sealed to the creator (and, ideally, to every invitee).
+         *
+         *     ``roles`` (webinars only, ``422 not_a_webinar`` otherwise): ``{usr-…: cohost | panelist | attendee}`` for existing
+         *     invitees (``422 not_an_invitee``). A new role applies from the person's next join.
          */
         CallUpdate: {
             /** Title */
@@ -10591,6 +10851,53 @@ interface components {
             sealed_keys?: {
                 [key: string]: string;
             } | null;
+            /** Roles */
+            roles?: {
+                [key: string]: 'cohost' | 'panelist' | 'attendee';
+            } | null;
+        };
+        /**
+         * CallWebinarMessage
+         * @description A webinar went live, ended, or changed its chat setting (same audience as ``call.started``). Everyone in the
+         *     room also gets a server-sent LiveKit data message on topic ``arbi.webinar`` (``{type: "state", …}``).
+         */
+        CallWebinarMessage: {
+            /**
+             * Type
+             * @default call.webinar
+             * @constant
+             */
+            type: 'call.webinar';
+            /** Call Ext Id */
+            call_ext_id: string;
+            /** Live */
+            live: boolean;
+            /**
+             * Chat
+             * @enum {string}
+             */
+            chat: 'panelists' | 'everyone';
+        };
+        /**
+         * CallWebinarSummary
+         * @description ``CallResponse.webinar``: the stage state and the viewer's role.
+         */
+        CallWebinarSummary: {
+            /** Live */
+            live: boolean;
+            /** Live At */
+            live_at?: string | null;
+            /**
+             * Chat
+             * @default panelists
+             * @enum {string}
+             */
+            chat: 'panelists' | 'everyone';
+            /**
+             * My Role
+             * @enum {string}
+             */
+            my_role: 'host' | 'cohost' | 'panelist' | 'attendee';
         };
         /** CallsConfigResponse */
         CallsConfigResponse: {
@@ -10791,6 +11098,11 @@ interface components {
             recording_ext_id?: string | null;
             /** Dedupe Key */
             dedupe_key?: string | null;
+            /**
+             * Deleted
+             * @default false
+             */
+            deleted: boolean;
             /** Workspace Ext Id */
             workspace_ext_id?: string | null;
             /**
@@ -10876,7 +11188,8 @@ interface components {
         };
         /**
          * ChatUpdatedMessage
-         * @description A chat changed (members, keys, title, a deleted message): refetch ``GET /v1/chats/{id}``.
+         * @description A chat changed (members, keys, title, a deleted message): refetch ``GET /v1/chats/{id}``. ``message`` is a
+         *     message changed in place (a deleted message's tombstone, ``deleted: true``): replace it in the thread.
          */
         ChatUpdatedMessage: {
             /**
@@ -10887,6 +11200,7 @@ interface components {
             type: 'chat.updated';
             /** Chat Ext Id */
             chat_ext_id: string;
+            message?: components['schemas']['ChatMessageResponse'] | null;
         };
         /** Chunk */
         Chunk: {
@@ -22327,6 +22641,7 @@ interface components {
             call_knock?: components['schemas']['CallKnockMessage'] | null;
             call_knock_resolved?: components['schemas']['CallKnockResolvedMessage'] | null;
             call_transcription?: components['schemas']['CallTranscriptionMessage'] | null;
+            call_webinar?: components['schemas']['CallWebinarMessage'] | null;
             chat_message?: components['schemas']['ChatMessageMessage'] | null;
             chat_updated?: components['schemas']['ChatUpdatedMessage'] | null;
             chat_read?: components['schemas']['ChatReadMessage'] | null;
@@ -22334,6 +22649,86 @@ interface components {
             notification?: components['schemas']['NotificationResponse'] | null;
             auth?: components['schemas']['AuthMessage'] | null;
         };
+        /**
+         * WebinarAttendee
+         * @description Someone in the room (``ListParticipants``, hidden people included), for the moderators' audience list.
+         */
+        WebinarAttendee: {
+            /** Identity */
+            identity: string;
+            /** Name */
+            name: string;
+            /** On Stage */
+            on_stage: boolean;
+            /** Hand Raised */
+            hand_raised: boolean;
+            /**
+             * Role
+             * @enum {string}
+             */
+            role: 'host' | 'cohost' | 'panelist' | 'attendee';
+        };
+        /** WebinarHand */
+        WebinarHand: {
+            /** Identity */
+            identity: string;
+            /** Name */
+            name: string;
+            /**
+             * Raised At
+             * Format: date-time
+             */
+            raised_at: string;
+        };
+        /** WebinarHandRequest */
+        WebinarHandRequest: {
+            /** Raised */
+            raised: boolean;
+        };
+        /**
+         * WebinarState
+         * @description ``GET /webinar``. ``hands`` (oldest first) and ``attendees`` are filled for the moderators only. ``attendees`` is
+         *     the audience: attendees in the room (promoted ones included) and team members who stepped off stage.
+         */
+        WebinarState: {
+            /** Live */
+            live: boolean;
+            /** Live At */
+            live_at?: string | null;
+            /**
+             * Chat
+             * @default panelists
+             * @enum {string}
+             */
+            chat: 'panelists' | 'everyone';
+            /**
+             * My Role
+             * @enum {string}
+             */
+            my_role: 'host' | 'cohost' | 'panelist' | 'attendee';
+            /** On Stage */
+            on_stage: boolean;
+            /**
+             * Hand Raised
+             * @default false
+             */
+            hand_raised: boolean;
+            /** Hands */
+            hands?: components['schemas']['WebinarHand'][];
+            /** Attendees */
+            attendees?: components['schemas']['WebinarAttendee'][];
+        };
+        /**
+         * WebinarUpdate
+         * @description Moderators: ``live`` true opens the stage, false ends the webinar for everyone (the room is closed);
+         *     ``chat`` sets who may chat.
+         */
+        WebinarUpdate: {
+            /** Live */
+            live?: boolean | null;
+            /** Chat */
+            chat?: ('panelists' | 'everyone') | null;
+        };
         /** WeeklyHours */
         WeeklyHours: {
             /**
@@ -30247,6 +30642,355 @@ interface operations {
             };
         };
     };
+    get_call_webinar: {
+        parameters: {
+            query?: {
+                link_version?: number | null;
+            };
+            header?: never;
+            path: {
+                call_ext_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    'application/json': components['schemas']['WebinarState'];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    'application/json': components['schemas']['HTTPValidationError'];
+                };
+            };
+        };
+    };
+    update_call_webinar: {
+        parameters: {
+            query?: {
+                link_version?: number | null;
+            };
+            header?: never;
+            path: {
+                call_ext_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                'application/json': components['schemas']['WebinarUpdate'];
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    'application/json': components['schemas']['WebinarState'];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    'application/json': components['schemas']['HTTPValidationError'];
+                };
+            };
+        };
+    };
+    raise_call_webinar_hand: {
+        parameters: {
+            query?: {
+                link_version?: number | null;
+            };
+            header?: never;
+            path: {
+                call_ext_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                'application/json': components['schemas']['WebinarHandRequest'];
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    'application/json': components['schemas']['WebinarState'];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    'application/json': components['schemas']['HTTPValidationError'];
+                };
+            };
+        };
+    };
+    promote_call_webinar_participant: {
+        parameters: {
+            query?: {
+                link_version?: number | null;
+            };
+            header?: never;
+            path: {
+                call_ext_id: string;
+                identity: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    'application/json': components['schemas']['HTTPValidationError'];
+                };
+            };
+        };
+    };
+    demote_call_webinar_participant: {
+        parameters: {
+            query?: {
+                link_version?: number | null;
+            };
+            header?: never;
+            path: {
+                call_ext_id: string;
+                identity: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    'application/json': components['schemas']['HTTPValidationError'];
+                };
+            };
+        };
+    };
+    list_call_webinar_questions: {
+        parameters: {
+            query?: {
+                link_version?: number | null;
+            };
+            header?: never;
+            path: {
+                call_ext_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    'application/json': components['schemas']['CallQuestionResponse'][];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    'application/json': components['schemas']['HTTPValidationError'];
+                };
+            };
+        };
+    };
+    ask_call_webinar_question: {
+        parameters: {
+            query?: {
+                link_version?: number | null;
+            };
+            header?: never;
+            path: {
+                call_ext_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                'application/json': components['schemas']['CallQuestionCreate'];
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    'application/json': components['schemas']['CallQuestionResponse'];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    'application/json': components['schemas']['HTTPValidationError'];
+                };
+            };
+        };
+    };
+    vote_call_webinar_question: {
+        parameters: {
+            query?: {
+                link_version?: number | null;
+            };
+            header?: never;
+            path: {
+                call_ext_id: string;
+                question_ext_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                'application/json': components['schemas']['CallQuestionVote'];
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    'application/json': components['schemas']['CallQuestionResponse'];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    'application/json': components['schemas']['HTTPValidationError'];
+                };
+            };
+        };
+    };
+    delete_call_webinar_question: {
+        parameters: {
+            query?: {
+                link_version?: number | null;
+            };
+            header?: never;
+            path: {
+                call_ext_id: string;
+                question_ext_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    'application/json': components['schemas']['HTTPValidationError'];
+                };
+            };
+        };
+    };
+    update_call_webinar_question: {
+        parameters: {
+            query?: {
+                link_version?: number | null;
+            };
+            header?: never;
+            path: {
+                call_ext_id: string;
+                question_ext_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                'application/json': components['schemas']['CallQuestionUpdate'];
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    'application/json': components['schemas']['CallQuestionResponse'];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    'application/json': components['schemas']['HTTPValidationError'];
+                };
+            };
+        };
+    };
     upload_chat_attachment: {
         parameters: {
             query?: never;