openapi: 3.1.0
info:
  title: Voice Platform API
  version: 1.0.0
paths:
  /v1/sessions:dial:
    post:
      operationId: createDial
      summary: Originate outbound call
      description: |-
        Originate a new outbound call. Returns immediately with the new
        `session_uuid`; call progress is delivered via webhooks.

        **Triggered webhooks:** `command.session.dial.accepted`, `session.ringing_started`,
        `session.early_media_started` (optional, NOT an answer), `session.answered`, `session.ended`
      tags:
        - callControl
      parameters:
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>`. See
            [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional client-generated key for a mutating endpoint. It identifies one method, route, query, content type,
            and exact raw body within the authenticated app. Reusing it for a different request returns 422. While its
            record exists, a retry replays the original accepted response when available. Keys are valid for 1 hour.
            Allowed characters: letters, digits, dot, hyphen, underscore; max 128 characters. See the Idempotency guide.
          required: false
          schema:
            type: string
      responses:
        '202':
          description: Dial accepted
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Call Control_createDial_Response_202'
        '400':
          description: |-
            Missing `Authorization`, malformed Bearer credentials, or an
            invalid request body. Body errors include missing `to`/`from`, a
            malformed number, or `ring_timeout_sec` / `max_duration_sec` out
            of range. Phone-format errors begin with `invalid_to:` or
            `invalid_from:` and require canonical E.164 with a leading `+`.
            A syntactically valid credential with an invalid API key
            returns `401` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateDialRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateDialRequestUnauthorizedError'
        '403':
          description: |-
            `from` is supported but not on this app's caller-ID allow-list. No call is placed.
            The stable machine-readable response code is `forbidden`; do not branch on the human message.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateDialRequestForbiddenError'
        '409':
          description: >-
            A request with this `Idempotency-Key` is already in progress. Wait for its result instead of re-sending. See
            the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateDialRequestConflictError'
        '413':
          description: Request body exceeds the endpoint's size limit.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateDialRequestContentTooLargeError'
        '415':
          description: 'A request with a JSON body must use `Content-Type: application/json`.'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateDialRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different request body. A key maps to one request; use a new key.
            See the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateDialRequestUnprocessableEntityError'
        '500':
          description: Internal gateway error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateDialRequestInternalServerError'
        '503':
          description: |-
            The idempotency store is unavailable so the request was not
            processed — retry with the same `Idempotency-Key`. (Outbound
            capacity exhaustion is reported as `529`, not `503`.)
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateDialRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties:
                from:
                  type: string
                  description: |-
                    Caller ID to present, in the same E.164 format with leading `+` as `to` (e.g. `+972527121102`).
                    The schema validates canonical syntax only. Runtime country policy must support
                    the number, and it must be on the app's caller-ID allow-list. A supported but
                    non-allow-listed value is rejected with `403 forbidden` (no call is placed,
                    no webhooks fire). Branch on the response `code`, not the human message.
                    The gateway does not substitute a default caller ID; an SDK MAY catch
                    `403 forbidden` for this operation and retry with its own configured approved default.
                max_duration_sec:
                  type: integer
                  description: Maximum total call duration in seconds. A typical value is 3600.
                ring_timeout_sec:
                  type: integer
                  description: |-
                    Pre-answer ring timeout in seconds, measured from when dialing begins
                    (the moment the request is accepted / `command.session.dial.accepted` is emitted), NOT from
                    when the destination phone starts ringing. Call setup and routing consume
                    part of this budget, so the callee experiences less ring time than the value
                    set here. On expiry the dial ends with `session.ended` (answered=false,
                    hangup_cause="timeout"). Distinct from `max_duration_sec`, the post-answer cap.
                to:
                  type: string
                  description: |-
                    Destination number in international E.164 format with leading `+` (e.g. `+972527121102`).
                    The schema validates canonical syntax only. Runtime country and trunk policies
                    determine whether the destination is currently dialable; an unsupported
                    destination is rejected with `400 invalid_request`.
              required:
                - from
                - max_duration_sec
                - ring_timeout_sec
                - to
  /v1/sessions:connectWebsocket:
    post:
      operationId: createSession
      summary: Create a standalone session
      description: |-
        Create a [standalone session](/api/sessions) that has no phone leg and exists only to
        bridge audio to an external WebSocket backend. Only `type: "websocket"` is
        supported. The session is born `connecting`; once the backend WebSocket
        is established it advances to `answered`. Its lifetime is bound to that
        WebSocket — when the backend disconnects (or never connects within the
        connect timeout) the session ends and a `session.ended` webhook is emitted.

        **Triggered webhooks:** `websocket.connected`, `websocket.disconnected`, `websocket.failed`,
        `session.ended`
      tags:
        - webSocket
      parameters:
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>`. See
            [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional client-generated key for a mutating endpoint. It identifies one method, route, query, content type,
            and exact raw body within the authenticated app. Reusing it for a different request returns 422. While its
            record exists, a retry replays the original accepted response when available. Keys are valid for 1 hour.
            Allowed characters: letters, digits, dot, hyphen, underscore; max 128 characters. See the Idempotency guide.
          required: false
          schema:
            type: string
      responses:
        '201':
          description: Session created. Born in the `connecting` state.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Session'
        '400':
          description: >-
            Missing `Authorization`, malformed Bearer credentials, or invalid request parameters. A syntactically valid
            credential with an invalid API key returns `401` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateSessionRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateSessionRequestUnauthorizedError'
        '403':
          description: >-
            Authenticated, but the caller is not permitted to perform this action — e.g. the caller-ID is not on the
            app's allow-list for `POST /v1/sessions:dial`, or a per-app resource cap has been reached (the room cap on
            `POST /api/v1/rooms`). (Acting on another application's session or room is **not** a `403`; that returns
            `404` — see SessionNotFound.)
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateSessionRequestForbiddenError'
        '409':
          description: >-
            A request with this `Idempotency-Key` is already in progress. Wait for its result instead of re-sending. See
            the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateSessionRequestConflictError'
        '413':
          description: Request body exceeds the endpoint's size limit.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateSessionRequestContentTooLargeError'
        '415':
          description: 'A request with a JSON body must use `Content-Type: application/json`.'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateSessionRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different request body. A key maps to one request; use a new key.
            See the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateSessionRequestUnprocessableEntityError'
        '500':
          description: Internal gateway error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateSessionRequestInternalServerError'
        '503':
          description: |-
            The idempotency store is unavailable so the request was not
            processed — retry with the same `Idempotency-Key`. (Capacity
            exhaustion is reported as `529`, not `503`.)
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateSessionRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties:
                type:
                  $ref: '#/components/schemas/V1SessionsConnectWebsocketPostRequestBodyContentApplicationJsonSchemaType'
                  description: Session type to create. Only `websocket` is supported.
                websocket:
                  $ref: '#/components/schemas/WebSocketRelayConfig'
              required:
                - type
                - websocket
  /v1/sessions:
    get:
      operationId: listSessions
      summary: List sessions
      description: |-
        List [sessions](/api/sessions) owned by your app, newest first (by `created_at`).
        This endpoint is not paginated — there is no cursor or page token. By
        default **all** matching sessions are returned in a single call.
        `limit` is optional and not clamped: omit it to return everything, or
        set it to cap the number returned. When `limit` is set and more
        sessions match than fit, `has_more` is `true`.

        The optional `caller_id`, `did`, `state`, `created_after` and
        `created_before` filters narrow the result set. They are
        AND-combined — a session must satisfy every supplied filter to appear.
        `has_more` reflects matches **after** filtering.
      tags:
        - callControl
      parameters:
        - name: limit
          in: query
          description: |-
            Optional cap on the number of sessions to return. Omit to return
            every matching session; when set, at most this many are returned and
            `has_more` indicates whether more matched. A non-positive value
            returns `400`.
          required: false
          schema:
            type: integer
        - name: caller_id
          in: query
          description: |-
            Filter to sessions whose caller exactly matches this canonical
            E.164 value. The schema validates country-neutral syntax only; this
            historical-data filter does not apply current trunk policy.
          required: false
          schema:
            type: string
        - name: did
          in: query
          description: |-
            Filter to sessions whose called DID exactly matches this canonical
            E.164 value. The schema validates country-neutral syntax only; this
            historical-data filter does not apply current trunk policy.
          required: false
          schema:
            type: string
        - name: state
          in: query
          description: Filter to sessions in this lifecycle state. Any other value returns `400`.
          required: false
          schema:
            $ref: '#/components/schemas/V1SessionsGetParametersState'
        - name: created_after
          in: query
          description: |-
            Inclusive lower bound on `created_at` (RFC 3339 UTC string).
            Only sessions created at or after this instant are returned. An
            invalid RFC 3339 value returns `400`.
          required: false
          schema:
            type: string
            format: date-time
        - name: created_before
          in: query
          description: |-
            Exclusive upper bound on `created_at` (RFC 3339 UTC string).
            Only sessions created strictly before this instant are returned. An
            invalid RFC 3339 value returns `400`.
          required: false
          schema:
            type: string
            format: date-time
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>`. See
            [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for details.
          required: true
          schema:
            type: string
      responses:
        '200':
          description: The matching sessions.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SessionListResponse'
        '400':
          description: |-
            Missing `Authorization`, malformed Bearer credentials, or an
            invalid query parameter — a non-positive `limit`, an unparseable
            `caller_id`/`did`, a `state` outside the enum, or an invalid RFC 3339
            `created_after`/`created_before`. A syntactically valid credential
            with an invalid API key returns `401` instead. Body is the standard error
            envelope, e.g. `{"success":false,"error":"Invalid limit (must be a
            positive integer)","code":"invalid_request","trace_id":"..."}`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ListSessionsRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ListSessionsRequestUnauthorizedError'
        '413':
          description: |-
            The matched set exceeds the system result ceiling. Narrow the query
            with filters and retry. The ceiling is checked before `limit`, so a
            smaller `limit` does not avoid it. Body is the standard error envelope
            with `code: result_set_too_large`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ListSessionsRequestContentTooLargeError'
        '429':
          description: >-
            Rate limit exceeded — a per-command, per-room, or per-app token bucket was empty. The `retry_after` field
            gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ListSessionsRequestTooManyRequestsError'
        '500':
          description: Internal gateway error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ListSessionsRequestInternalServerError'
  /v1/sessions/{uuid}:
    get:
      operationId: getSessionDetails
      summary: Get session details
      description: Look up details for a [session](/api/sessions) owned by your app.
      tags:
        - callControl
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) UUID (format `{5-char-prefix}-{uuid}`).'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>`. See
            [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for details.
          required: true
          schema:
            type: string
      responses:
        '200':
          description: Session details
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SessionDetails'
        '400':
          description: >-
            Missing `Authorization`, malformed Bearer credentials, or invalid request parameters. A syntactically valid
            credential with an invalid API key returns `401` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/GetSessionDetailsRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/GetSessionDetailsRequestUnauthorizedError'
        '404':
          description: >-
            Session not found. A session owned by a *different* application returns this same `404` (never a `403`) so
            the response cannot be used to probe for the existence of another tenant's session.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/GetSessionDetailsRequestNotFoundError'
        '500':
          description: Internal gateway error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/GetSessionDetailsRequestInternalServerError'
    delete:
      operationId: deleteSession
      summary: Delete session
      description: |-
        Delete a session. The request is accepted immediately and session
        termination is reported by the deferred `session.ended` webhook.

        **Triggered webhooks:** `session.ended` (deferred)
      tags:
        - sessions
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) UUID (format `{5-char-prefix}-{uuid}`).'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>`. See
            [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional client-generated key for a mutating endpoint. It identifies one method, route, query, content type,
            and exact raw body within the authenticated app. Reusing it for a different request returns 422. While its
            record exists, a retry replays the original accepted response when available. Keys are valid for 1 hour.
            Allowed characters: letters, digits, dot, hyphen, underscore; max 128 characters. See the Idempotency guide.
          required: false
          schema:
            type: string
      responses:
        '202':
          description: Command accepted for async execution
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AsyncCommandResponse'
        '400':
          description: >-
            Missing `Authorization`, malformed Bearer credentials, or invalid request parameters. A syntactically valid
            credential with an invalid API key returns `401` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DeleteSessionRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DeleteSessionRequestUnauthorizedError'
        '404':
          description: The requested resource was not found or is not owned by the authenticated app.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DeleteSessionRequestNotFoundError'
        '409':
          description: >-
            The request cannot be completed because of state conflict — typically the session is terminating, or the
            resource (room, recording) is in a state incompatible with this command. On an operation that accepts
            `Idempotency-Key`, this status can also mean the original request with that key is still in progress; wait
            for its result rather than sending a different request with the same key.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DeleteSessionRequestConflictError'
        '413':
          description: Request body exceeds the endpoint's size limit.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DeleteSessionRequestContentTooLargeError'
        '415':
          description: 'A request with a JSON body must use `Content-Type: application/json`.'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DeleteSessionRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different request body. A key maps to one request; use a new key.
            See the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DeleteSessionRequestUnprocessableEntityError'
        '500':
          description: Internal gateway error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DeleteSessionRequestInternalServerError'
        '503':
          description: >-
            When an `Idempotency-Key` was supplied, the idempotency store is unavailable and the request was NOT
            processed; retry with the same key. Some operations can also return `503` for an unavailable room/session
            source or another documented dependency even when no key was supplied; in that case this response does not
            imply idempotency-store failure. See the operation description and the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DeleteSessionRequestServiceUnavailableError'
  /v1/sessions/{uuid}/answer:
    post:
      operationId: answerACall
      summary: Answer a call
      description: |-
        Answer an incoming call. Asynchronous command — success is signalled by
        the `session.answered` webhook; a call that never answers surfaces via the
        eventual `session.ended` `{answered:false}`.

        **Triggered webhooks:** `session.answered`
      tags:
        - callControl
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) UUID (format `{5-char-prefix}-{uuid}`).'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>`. See
            [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional client-generated key for a mutating endpoint. It identifies one method, route, query, content type,
            and exact raw body within the authenticated app. Reusing it for a different request returns 422. While its
            record exists, a retry replays the original accepted response when available. Keys are valid for 1 hour.
            Allowed characters: letters, digits, dot, hyphen, underscore; max 128 characters. See the Idempotency guide.
          required: false
          schema:
            type: string
      responses:
        '202':
          description: Command accepted for async execution
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AsyncCommandResponse'
        '400':
          description: >-
            Missing `Authorization`, malformed Bearer credentials, or invalid request parameters. A syntactically valid
            credential with an invalid API key returns `401` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AnswerACallRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AnswerACallRequestUnauthorizedError'
        '404':
          description: >-
            Session not found. A session owned by a *different* application returns this same `404` (never a `403`) so
            the response cannot be used to probe for the existence of another tenant's session.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AnswerACallRequestNotFoundError'
        '409':
          description: >-
            The request cannot be completed because of state conflict — typically the session is terminating, or the
            resource (room, recording) is in a state incompatible with this command. On an operation that accepts
            `Idempotency-Key`, this status can also mean the original request with that key is still in progress; wait
            for its result rather than sending a different request with the same key.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AnswerACallRequestConflictError'
        '413':
          description: Request body exceeds the endpoint's size limit.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AnswerACallRequestContentTooLargeError'
        '415':
          description: 'A request with a JSON body must use `Content-Type: application/json`.'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AnswerACallRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different request body. A key maps to one request; use a new key.
            See the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AnswerACallRequestUnprocessableEntityError'
        '500':
          description: Internal gateway error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AnswerACallRequestInternalServerError'
        '503':
          description: >-
            When an `Idempotency-Key` was supplied, the idempotency store is unavailable and the request was NOT
            processed; retry with the same key. Some operations can also return `503` for an unavailable room/session
            source or another documented dependency even when no key was supplied; in that case this response does not
            imply idempotency-store failure. See the operation description and the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AnswerACallRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/CommandRequest'
  /api/v1/rooms:
    get:
      operationId: listRooms
      summary: List rooms
      description: |-
        List [rooms](/api/rooms) owned by the authenticated app, sorted
        newest-first by `created_at`. Filter is implicit: only rooms owned
        by the authenticated app are returned — apps cannot enumerate other
        apps' rooms.

        This endpoint is not paginated: there is no cursor or page token. By default **all** rooms
        owned by the app are returned. When `limit` is set and more rooms matched
        than it allowed, `has_more` is `true` — raise or omit `limit` to retrieve
        all of them.
      tags:
        - rooms
      parameters:
        - name: limit
          in: query
          description: |-
            Optional cap on the number of rooms to return. Omit to return every
            room owned by the app (never clamped); when set, at most this many
            are returned. A non-positive value returns `400`.
          required: false
          schema:
            type: integer
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>`. See
            [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for details.
          required: true
          schema:
            type: string
      responses:
        '200':
          description: Rooms owned by the app
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RoomListResponse'
        '400':
          description: |-
            Missing `Authorization`, malformed Bearer credentials, or an
            invalid `limit`. A syntactically valid credential with an invalid
            API key returns `401` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ListRoomsRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ListRoomsRequestUnauthorizedError'
        '413':
          description: |-
            The app owns more rooms than the system result ceiling. The ceiling
            is checked before `limit`, and this endpoint has no narrowing filter,
            so changing `limit` cannot make the request succeed. Body is the
            standard error envelope with `code: result_set_too_large`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ListRoomsRequestContentTooLargeError'
        '429':
          description: >-
            Rate limit exceeded — a per-command, per-room, or per-app token bucket was empty. The `retry_after` field
            gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ListRoomsRequestTooManyRequestsError'
        '500':
          description: Internal gateway error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ListRoomsRequestInternalServerError'
    post:
      operationId: createRoom
      summary: Create a room
      description: |-
        Create a new [room](/api/rooms).

        **Triggered webhooks:** `room.created` (immediate)
      tags:
        - rooms
      parameters:
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>`. See
            [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional client-generated key for a mutating endpoint. It identifies one method, route, query, content type,
            and exact raw body within the authenticated app. Reusing it for a different request returns 422. While its
            record exists, a retry replays the original accepted response when available. Keys are valid for 1 hour.
            Allowed characters: letters, digits, dot, hyphen, underscore; max 128 characters. See the Idempotency guide.
          required: false
          schema:
            type: string
      responses:
        '201':
          description: Room created
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Rooms_createRoom_Response_201'
        '400':
          description: >-
            Missing `Authorization`, malformed Bearer credentials, or invalid request parameters. A syntactically valid
            credential with an invalid API key returns `401` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateRoomRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateRoomRequestUnauthorizedError'
        '403':
          description: >-
            The application has reached its maximum number of concurrent

            rooms. This cap bounds how many rooms an app may own at once

            (not how fast it creates them), so it is returned as `403`

            (`code: forbidden`) rather than `429`. The default cap is 100

            rooms per application; an operator may raise or lower it per

            application. Delete a room before creating another.


            Body is

            `{"success":false,"error":"Maximum number of rooms reached for this
            application","code":"forbidden","trace_id":"…"}`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateRoomRequestForbiddenError'
        '409':
          description: >-
            A request with this `Idempotency-Key` is already in progress. Wait for its result instead of re-sending. See
            the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateRoomRequestConflictError'
        '413':
          description: Request body exceeds the endpoint's size limit.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateRoomRequestContentTooLargeError'
        '415':
          description: 'A request with a JSON body must use `Content-Type: application/json`.'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateRoomRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different request body. A key maps to one request; use a new key.
            See the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateRoomRequestUnprocessableEntityError'
        '429':
          description: >-
            Rate limit exceeded — a per-command, per-room, or per-app token bucket was empty. The `retry_after` field
            gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateRoomRequestTooManyRequestsError'
        '500':
          description: Internal gateway error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateRoomRequestInternalServerError'
        '503':
          description: >-
            When an `Idempotency-Key` was supplied, the idempotency store is unavailable and the request was NOT
            processed; retry with the same key. Some operations can also return `503` for an unavailable room/session
            source or another documented dependency even when no key was supplied; in that case this response does not
            imply idempotency-store failure. See the operation description and the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateRoomRequestServiceUnavailableError'
      requestBody:
        description: Send an empty JSON object (`{}`). No request fields are defined.
        content:
          application/json:
            schema:
              type: object
              properties: {}
  /api/v1/rooms/{room_id}:
    delete:
      operationId: deleteRoom
      summary: Delete room
      description: |-
        Destroy a [room](/api/rooms). Kicks all members, stops recording and playback.

        **Asynchronous teardown.** Returns `202 Accepted` with
        `{room_id, status: "deleting"}`. The gateway emits `command.room.delete.accepted`
        immediately when the delete is requested, then `room.deleted`
        later once teardown is confirmed (or with `reason: "timeout"`
        if confirmation does not arrive).

        **Triggered webhooks:** `command.room.delete.accepted` (immediate), `room.deleted`
        (deferred, emitted when the underlying media operation completes or with `reason: "timeout"`)
      tags:
        - rooms
      parameters:
        - name: room_id
          in: path
          description: |-
            [Room](/api/rooms) ID
            (format `{prefix}-room-{uuid}`). The UUID portion is lowercase
            hexadecimal — uppercase hex is rejected with 400.
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>`. See
            [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for details.
          required: true
          schema:
            type: string
      responses:
        '202':
          description: Room deletion accepted
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Rooms_deleteRoom_Response_202'
        '400':
          description: >-
            Missing `Authorization`, malformed Bearer credentials, or invalid request parameters. A syntactically valid
            credential with an invalid API key returns `401` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DeleteRoomRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DeleteRoomRequestUnauthorizedError'
        '404':
          description: The requested resource was not found or is not owned by the authenticated app.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DeleteRoomRequestNotFoundError'
        '500':
          description: Internal gateway error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DeleteRoomRequestInternalServerError'
    get:
      operationId: getRoomStatus
      summary: Get room status
      description: Return the canonical [room](/api/rooms) resource.
      tags:
        - rooms
      parameters:
        - name: room_id
          in: path
          description: |-
            [Room](/api/rooms) ID
            (format `{prefix}-room-{uuid}`). The UUID portion is lowercase
            hexadecimal — uppercase hex is rejected with 400.
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>`. See
            [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for details.
          required: true
          schema:
            type: string
      responses:
        '200':
          description: Room status
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Room'
        '400':
          description: >-
            Missing `Authorization`, malformed Bearer credentials, or invalid request parameters. A syntactically valid
            credential with an invalid API key returns `401` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/GetRoomStatusRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/GetRoomStatusRequestUnauthorizedError'
        '404':
          description: The requested resource was not found or is not owned by the authenticated app.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/GetRoomStatusRequestNotFoundError'
        '500':
          description: Internal gateway error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/GetRoomStatusRequestInternalServerError'
  /api/v1/rooms/{room_id}/members:
    get:
      operationId: listRoomMembers
      summary: List room members
      description: |-
        Return active [room members](/api/room-members), sorted by session
        `uuid` ascending.

        This endpoint is not paginated: there is no cursor or page token. By default **all** members
        of the room are returned. When `limit` is set and more members matched
        than it allowed, `has_more` is `true` — raise or omit `limit` to retrieve
        all of them.
      tags:
        - roomMembers
      parameters:
        - name: room_id
          in: path
          description: |-
            [Room](/api/rooms) ID
            (format `{prefix}-room-{uuid}`). The UUID portion is lowercase
            hexadecimal — uppercase hex is rejected with 400.
          required: true
          schema:
            type: string
        - name: limit
          in: query
          description: |-
            Optional cap on the number of members to return. Omit to return every
            member of the room (never clamped); when set, at most this many are
            returned. A non-positive value returns `400`.
          required: false
          schema:
            type: integer
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>`. See
            [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for details.
          required: true
          schema:
            type: string
      responses:
        '200':
          description: Members of the room
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RoomMemberListResponse'
        '400':
          description: |-
            Missing `Authorization`, malformed Bearer credentials, or an
            invalid `limit`. A syntactically valid credential with an invalid
            API key returns `401` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ListRoomMembersRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ListRoomMembersRequestUnauthorizedError'
        '404':
          description: |-
            Room not found. A room owned by a *different* application returns
            this same `404` (never a `403`), so the response cannot confirm
            that another tenant's room exists.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ListRoomMembersRequestNotFoundError'
        '413':
          description: |-
            The room has more members than the system result ceiling. The ceiling
            is checked before `limit`, and this endpoint has no narrowing filter,
            so changing `limit` cannot make the request succeed. Body is the
            standard error envelope with `code: result_set_too_large`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ListRoomMembersRequestContentTooLargeError'
        '500':
          description: Internal gateway error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ListRoomMembersRequestInternalServerError'
    post:
      operationId: addRoomMember
      summary: Add a session to the room
      description: |-
        **Rate limit: Per room** · **Burst:** 100 · **Refill:** 30 req/s

        Add a [room member](/api/room-members). This is the canonical join endpoint.
        Members join unmuted by default; pass `"muted": true` to join muted.
        The member is identified by its session UUID, the
        same identifier `GET /api/v1/rooms/{room_id}/members` returns.

        **Triggered webhooks:** `room.member.joined` (deferred, emitted when the underlying media operation completes)

        Returns 200 if the session is already in this room (idempotent).
        Returns 409 if the session is still mid-join in a different room.
      tags:
        - roomMembers
      parameters:
        - name: room_id
          in: path
          description: |-
            [Room](/api/rooms) ID
            (format `{prefix}-room-{uuid}`). The UUID portion is lowercase
            hexadecimal — uppercase hex is rejected with 400.
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>`. See
            [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional client-generated key for a mutating endpoint. It identifies one method, route, query, content type,
            and exact raw body within the authenticated app. Reusing it for a different request returns 422. While its
            record exists, a retry replays the original accepted response when available. Keys are valid for 1 hour.
            Allowed characters: letters, digits, dot, hyphen, underscore; max 128 characters. See the Idempotency guide.
          required: false
          schema:
            type: string
      responses:
        '200':
          description: Session already joined to this room (idempotent)
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Room Members_addRoomMember_Response_200'
        '400':
          description: |-
            Missing `Authorization`, malformed Bearer credentials, a missing
            `session_uuid`, or an invalid JSON body. A syntactically valid
            credential with an invalid API key returns `401` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AddRoomMemberRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AddRoomMemberRequestUnauthorizedError'
        '404':
          description: |-
            Room or session not found. A room or session owned by a *different*
            application returns this same `404` (never a `403`), so the response
            cannot confirm that another tenant's resource exists.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AddRoomMemberRequestNotFoundError'
        '409':
          description: |-
            Either the session is still mid-join in a different room
            (`code: conflict`), or the room is at its member cap and the member
            was not seated (`code: room_full`). The member cap is the
            application's `max_members` value, or the system default (250) when
            unset. A count cap, not a rate limit — there is no `retry_after`.
            The body carries no count, cap, or other room internals.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '413':
          description: Request body exceeds the endpoint's size limit.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AddRoomMemberRequestContentTooLargeError'
        '415':
          description: 'A request with a JSON body must use `Content-Type: application/json`.'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AddRoomMemberRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different request body. A key maps to one request; use a new key.
            See the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AddRoomMemberRequestUnprocessableEntityError'
        '429':
          description: >-
            Rate limit exceeded — a per-command, per-room, or per-app token bucket was empty. The `retry_after` field
            gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AddRoomMemberRequestTooManyRequestsError'
        '500':
          description: Internal gateway error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AddRoomMemberRequestInternalServerError'
        '503':
          description: >-
            When an `Idempotency-Key` was supplied, the idempotency store is unavailable and the request was NOT
            processed; retry with the same key. Some operations can also return `503` for an unavailable room/session
            source or another documented dependency even when no key was supplied; in that case this response does not
            imply idempotency-store failure. See the operation description and the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AddRoomMemberRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties:
                muted:
                  type: boolean
                  default: false
                  description: |-
                    If true, the member joins muted. Omitted or false
                    joins the member unmuted (audible immediately).
                session_uuid:
                  type: string
                  description: |-
                    Session UUID of the member to add — the identifier
                    `GET /api/v1/rooms/{room_id}/members` returns.
              required:
                - session_uuid
  /api/v1/rooms/{room_id}/members/{uuid}:
    get:
      operationId: getRoomMember
      summary: Get a single room member
      description: |-
        Return one [room member](/api/room-members). `{uuid}` is the
        member's session UUID, the same identifier
        `GET /api/v1/rooms/{room_id}/members` returns. The response is the same
        member object the list returns: `{uuid, muted}` and nothing more —
        talking state is delivered only via the `room.member.talking` webhook,
        never on this object.
      tags:
        - roomMembers
      parameters:
        - name: room_id
          in: path
          description: |-
            [Room](/api/rooms) ID
            (format `{prefix}-room-{uuid}`). The UUID portion is lowercase
            hexadecimal — uppercase hex is rejected with 400.
          required: true
          schema:
            type: string
        - name: uuid
          in: path
          description: '[Session](/api/sessions) UUID (format `{5-char-prefix}-{uuid}`).'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>`. See
            [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for details.
          required: true
          schema:
            type: string
      responses:
        '200':
          description: Member of the room
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RoomMember'
        '400':
          description: >-
            Missing `Authorization`, malformed Bearer credentials, or invalid request parameters. A syntactically valid
            credential with an invalid API key returns `401` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/GetRoomMemberRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/GetRoomMemberRequestUnauthorizedError'
        '404':
          description: |-
            No such member: the room is unknown, the session is unknown, or the
            session is not a member of this room — all indistinguishable by
            design. A room or session owned by a *different* application returns
            this same `404` (never a `403`), so the response cannot confirm that
            another tenant's resource exists.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/GetRoomMemberRequestNotFoundError'
        '500':
          description: Internal gateway error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/GetRoomMemberRequestInternalServerError'
    delete:
      operationId: removeRoomMember
      summary: Remove a member from the room
      description: |-
        **Rate limit: Per room** · **Burst:** 100 · **Refill:** 30 req/s

        Remove a [room member](/api/room-members). This is the canonical leave endpoint.
        `{uuid}` is the member's session UUID, the same identifier
        `GET /api/v1/rooms/{room_id}/members` returns.

        **Triggered webhooks:** `room.member.left` (deferred, emitted when the underlying media operation completes)
      tags:
        - roomMembers
      parameters:
        - name: room_id
          in: path
          description: |-
            [Room](/api/rooms) ID
            (format `{prefix}-room-{uuid}`). The UUID portion is lowercase
            hexadecimal — uppercase hex is rejected with 400.
          required: true
          schema:
            type: string
        - name: uuid
          in: path
          description: '[Session](/api/sessions) UUID (format `{5-char-prefix}-{uuid}`).'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>`. See
            [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for details.
          required: true
          schema:
            type: string
      responses:
        '202':
          description: Leaving room
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Room Members_removeRoomMember_Response_202'
        '400':
          description: >-
            Missing `Authorization`, malformed Bearer credentials, or invalid request parameters. A syntactically valid
            credential with an invalid API key returns `401` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RemoveRoomMemberRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RemoveRoomMemberRequestUnauthorizedError'
        '404':
          description: |-
            Room not found, session unknown, or the session is not
            a member of this room. A room or session owned by a *different*
            application returns this same `404` (never a `403`), so the response
            cannot confirm that another tenant's resource exists.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RemoveRoomMemberRequestNotFoundError'
        '409':
          description: Session is still joining (no member assignment yet)
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RemoveRoomMemberRequestConflictError'
        '429':
          description: >-
            Rate limit exceeded — a per-command, per-room, or per-app token bucket was empty. The `retry_after` field
            gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RemoveRoomMemberRequestTooManyRequestsError'
        '500':
          description: Internal gateway error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RemoveRoomMemberRequestInternalServerError'
  /v1/sessions/{uuid}/room/mute:
    post:
      operationId: muteRoomMember
      summary: Mute room member
      description: |-
        **Rate limit: Per command** · **Burst:** 15 · **Refill:** 10 req/s

        Mute a [room member](/api/room-members).

        **Triggered webhooks:** `room.member.muted` (deferred, emitted when the underlying media operation completes)
      tags:
        - roomMembers
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) UUID (format `{5-char-prefix}-{uuid}`).'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>`. See
            [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional client-generated key for a mutating endpoint. It identifies one method, route, query, content type,
            and exact raw body within the authenticated app. Reusing it for a different request returns 422. While its
            record exists, a retry replays the original accepted response when available. Keys are valid for 1 hour.
            Allowed characters: letters, digits, dot, hyphen, underscore; max 128 characters. See the Idempotency guide.
          required: false
          schema:
            type: string
      responses:
        '202':
          description: Muting member
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Room Members_muteRoomMember_Response_202'
        '400':
          description: >-
            Missing `Authorization`, malformed Bearer credentials, or invalid request parameters. A syntactically valid
            credential with an invalid API key returns `401` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/MuteRoomMemberRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/MuteRoomMemberRequestUnauthorizedError'
        '404':
          description: The requested resource was not found or is not owned by the authenticated app.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/MuteRoomMemberRequestNotFoundError'
        '409':
          description: |
            The member is already muted or still joining, or a request with
            this `Idempotency-Key` is already in progress (`code: conflict`).
          content:
            application/json:
              schema:
                description: Any type
        '413':
          description: Request body exceeds the endpoint's size limit.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/MuteRoomMemberRequestContentTooLargeError'
        '415':
          description: 'A request with a JSON body must use `Content-Type: application/json`.'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/MuteRoomMemberRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different request body. A key maps to one request; use a new key.
            See the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/MuteRoomMemberRequestUnprocessableEntityError'
        '500':
          description: Internal gateway error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/MuteRoomMemberRequestInternalServerError'
        '503':
          description: >-
            When an `Idempotency-Key` was supplied, the idempotency store is unavailable and the request was NOT
            processed; retry with the same key. Some operations can also return `503` for an unavailable room/session
            source or another documented dependency even when no key was supplied; in that case this response does not
            imply idempotency-store failure. See the operation description and the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/MuteRoomMemberRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/CommandRequest'
  /v1/sessions/{uuid}/room/unmute:
    post:
      operationId: unmuteRoomMember
      summary: Unmute room member
      description: |-
        **Rate limit: Per command** · **Burst:** 15 · **Refill:** 10 req/s

        Unmute a [room member](/api/room-members).

        **Triggered webhooks:** `room.member.unmuted` (deferred, emitted when the underlying media operation completes)
      tags:
        - roomMembers
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) UUID (format `{5-char-prefix}-{uuid}`).'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>`. See
            [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional client-generated key for a mutating endpoint. It identifies one method, route, query, content type,
            and exact raw body within the authenticated app. Reusing it for a different request returns 422. While its
            record exists, a retry replays the original accepted response when available. Keys are valid for 1 hour.
            Allowed characters: letters, digits, dot, hyphen, underscore; max 128 characters. See the Idempotency guide.
          required: false
          schema:
            type: string
      responses:
        '202':
          description: Unmuting member
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Room Members_unmuteRoomMember_Response_202'
        '400':
          description: >-
            Missing `Authorization`, malformed Bearer credentials, or invalid request parameters. A syntactically valid
            credential with an invalid API key returns `401` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UnmuteRoomMemberRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UnmuteRoomMemberRequestUnauthorizedError'
        '404':
          description: The requested resource was not found or is not owned by the authenticated app.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UnmuteRoomMemberRequestNotFoundError'
        '409':
          description: |
            The member is already unmuted or still joining, or a request with
            this `Idempotency-Key` is already in progress (`code: conflict`).
          content:
            application/json:
              schema:
                description: Any type
        '413':
          description: Request body exceeds the endpoint's size limit.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UnmuteRoomMemberRequestContentTooLargeError'
        '415':
          description: 'A request with a JSON body must use `Content-Type: application/json`.'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UnmuteRoomMemberRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different request body. A key maps to one request; use a new key.
            See the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UnmuteRoomMemberRequestUnprocessableEntityError'
        '500':
          description: Internal gateway error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UnmuteRoomMemberRequestInternalServerError'
        '503':
          description: >-
            When an `Idempotency-Key` was supplied, the idempotency store is unavailable and the request was NOT
            processed; retry with the same key. Some operations can also return `503` for an unavailable room/session
            source or another documented dependency even when no key was supplied; in that case this response does not
            imply idempotency-store failure. See the operation description and the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UnmuteRoomMemberRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/CommandRequest'
  /v1/sessions/{uuid}/room/volume:
    post:
      operationId: setRoomMemberVolume
      summary: Set room member volume
      description: |-
        Adjust how loud a single [room member](/api/room-members) is, addressed by the member's
        session UUID. Independent of the room playback volume (`POST /rooms/{room_id}/playback/volume`).

        Member volume uses a coarse 1-9 notch scale (5 = normal/unchanged, 1 = quietest,
        9 = loudest) — a different scale from room playback (0-200). `1` is the quietest
        setting but is NOT silence; to silence a member use the mute command instead.

        `direction` selects which side of the member's audio to adjust: `out` =
        how loud this member hears the room; `in` = how loud this member is heard by the
        room; `both` = apply to both.

        **Triggered webhooks:** `room.member.volume_changed` `{volume, direction}`
        (immediate; exactly one event per command, including `direction: both`).
      tags:
        - roomMembers
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) UUID (format `{5-char-prefix}-{uuid}`).'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>`. See
            [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional client-generated key for a mutating endpoint. It identifies one method, route, query, content type,
            and exact raw body within the authenticated app. Reusing it for a different request returns 422. While its
            record exists, a retry replays the original accepted response when available. Keys are valid for 1 hour.
            Allowed characters: letters, digits, dot, hyphen, underscore; max 128 characters. See the Idempotency guide.
          required: false
          schema:
            type: string
      responses:
        '202':
          description: Member volume set
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Room Members_setRoomMemberVolume_Response_202'
        '400':
          description: >-
            Missing `Authorization`, malformed Bearer credentials, or invalid request parameters. A syntactically valid
            credential with an invalid API key returns `401` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SetRoomMemberVolumeRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SetRoomMemberVolumeRequestUnauthorizedError'
        '404':
          description: Session is not in any room
          content:
            application/json:
              schema:
                description: Any type
        '409':
          description: |
            The session is still joining (no member assigned yet), or a request
            with this `Idempotency-Key` is already in progress (`code: conflict`).
          content:
            application/json:
              schema:
                description: Any type
        '413':
          description: Request body exceeds the endpoint's size limit.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SetRoomMemberVolumeRequestContentTooLargeError'
        '415':
          description: 'A request with a JSON body must use `Content-Type: application/json`.'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SetRoomMemberVolumeRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different request body. A key maps to one request; use a new key.
            See the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SetRoomMemberVolumeRequestUnprocessableEntityError'
        '500':
          description: Internal gateway error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SetRoomMemberVolumeRequestInternalServerError'
        '503':
          description: >-
            When an `Idempotency-Key` was supplied, the idempotency store is unavailable and the request was NOT
            processed; retry with the same key. Some operations can also return `503` for an unavailable room/session
            source or another documented dependency even when no key was supplied; in that case this response does not
            imply idempotency-store failure. See the operation description and the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SetRoomMemberVolumeRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties:
                operation_uuid:
                  type: string
                  format: uuid
                  description: >-
                    Optional caller-supplied per-command correlation id, a bare lowercase RFC-4122 v4 UUID (no prefix).
                    Echoed back as `operation_uuid` in the 202 ack. A later lifecycle webhook carries it only when the
                    gateway can unambiguously associate that event with this command; the field is correlation, not
                    proof of causation. When omitted, the gateway mints one. Not an idempotency key — request
                    deduplication is the `Idempotency-Key` header. Invalid input (not a v4 UUID) is rejected with `400
                    invalid_request`.
                direction:
                  $ref: '#/components/schemas/V1SessionsUuidRoomVolumePostRequestBodyContentApplicationJsonSchemaDirection'
                  description: Which side to adjust. out = member hears room; in = member heard by room; both = both.
                volume:
                  type: integer
                  description: Member volume (1-9). 5 = normal/unchanged, 1 = quietest, 9 = loudest.
              required:
                - direction
                - volume
  /api/v1/rooms/{room_id}/playback/pause:
    post:
      operationId: pauseRoomPlayback
      summary: Pause/resume room playback
      description: >-
        Toggle pause/resume of room playback. If the room is currently playing,

        this pauses it and emits `command.room.playback.pause.accepted`; if it is already paused, this

        resumes it and emits `command.room.playback.resume.accepted`. The webhook's event name tells

        you which transition occurred, so consumers CAN distinguish a pause from a

        resume.


        **Triggered webhooks:** `command.room.playback.pause.accepted` or `command.room.playback.resume.accepted`
        (immediate)
      tags:
        - roomPlayback
      parameters:
        - name: room_id
          in: path
          description: |-
            [Room](/api/rooms) ID
            (format `{prefix}-room-{uuid}`). The UUID portion is lowercase
            hexadecimal — uppercase hex is rejected with 400.
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>`. See
            [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for details.
          required: true
          schema:
            type: string
      responses:
        '202':
          description: Room playback command accepted for asynchronous execution
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RoomAsyncCommandResponse'
        '400':
          description: >-
            Missing `Authorization`, malformed Bearer credentials, or invalid request parameters. A syntactically valid
            credential with an invalid API key returns `401` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PauseRoomPlaybackRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PauseRoomPlaybackRequestUnauthorizedError'
        '404':
          description: Room not found
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PauseRoomPlaybackRequestNotFoundError'
        '429':
          description: >-
            Rate limit exceeded — a per-command, per-room, or per-app token bucket was empty. The `retry_after` field
            gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PauseRoomPlaybackRequestTooManyRequestsError'
        '500':
          description: Internal gateway error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PauseRoomPlaybackRequestInternalServerError'
        '503':
          description: The room source node is unavailable, so the command was not dispatched.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PauseRoomPlaybackRequestServiceUnavailableError'
  /api/v1/rooms/{room_id}/playback/play:
    post:
      operationId: playAudioInRoom
      summary: Play audio in room
      description: |-
        **Rate limit: Per room** · **Burst:** 8 · **Refill:** 3 req/s

        Start playing audio URLs into a room.

        Before accepting finite room playback, the gateway probes each source
        with HEAD first and falls back to a ranged GET. A source that cannot be
        prepared returns a synchronous HTTP error, and no playback webhook is emitted.

        **Triggered webhooks:** `command.room.playback.start.accepted` (immediate),
        `room.playback.ended` (deferred, on natural completion or API stop), and
        `room.playback.failed` (deferred, on playback error or timeout)
      tags:
        - roomPlayback
      parameters:
        - name: room_id
          in: path
          description: |-
            [Room](/api/rooms) ID
            (format `{prefix}-room-{uuid}`). The UUID portion is lowercase
            hexadecimal — uppercase hex is rejected with 400.
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>`. See
            [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional client-generated key for a mutating endpoint. It identifies one method, route, query, content type,
            and exact raw body within the authenticated app. Reusing it for a different request returns 422. While its
            record exists, a retry replays the original accepted response when available. Keys are valid for 1 hour.
            Allowed characters: letters, digits, dot, hyphen, underscore; max 128 characters. See the Idempotency guide.
          required: false
          schema:
            type: string
      responses:
        '202':
          description: Room playback command accepted for asynchronous execution
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RoomAsyncCommandResponse'
        '400':
          description: >-
            Missing `Authorization`, malformed Bearer credentials, or invalid request parameters. A syntactically valid
            credential with an invalid API key returns `401` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PlayAudioInRoomRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PlayAudioInRoomRequestUnauthorizedError'
        '404':
          description: The requested resource was not found or is not owned by the authenticated app.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PlayAudioInRoomRequestNotFoundError'
        '409':
          description: A room playback transition is already in progress; retry after it settles.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PlayAudioInRoomRequestConflictError'
        '413':
          description: Request body exceeds the endpoint's size limit.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PlayAudioInRoomRequestContentTooLargeError'
        '415':
          description: 'A request with a JSON body must use `Content-Type: application/json`.'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PlayAudioInRoomRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different request body. A key maps to one request; use a new key.
            See the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PlayAudioInRoomRequestUnprocessableEntityError'
        '429':
          description: >-
            Rate limit exceeded — a per-command, per-room, or per-app token bucket was empty. The `retry_after` field
            gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PlayAudioInRoomRequestTooManyRequestsError'
        '500':
          description: Internal gateway error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PlayAudioInRoomRequestInternalServerError'
        '502':
          description: The playback source is unavailable, so the command was not accepted.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PlayAudioInRoomRequestBadGatewayError'
        '503':
          description: |-
            The idempotency store or room source is unavailable, or existing playback could not be stopped safely
            before replacement.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PlayAudioInRoomRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/Room Playback_playAudioInRoom_Request'
  /api/v1/rooms/{room_id}/playback/record:
    post:
      operationId: startRoomRecording
      summary: Start recording room audio
      description: |-
        Start one persistent mixed [Recording](/api/recording) of the room. The
        accepted [Operation](/api) and Recording share the flat response
        body. The Recording remains active while the room is empty and across
        service recovery. The response and webhooks expose its opaque
        `recording_uuid` and signed, time-bounded public URLs; internal paths are
        not exposed.

        **Triggered webhooks:** `command.recording.start.accepted` immediately, followed by
        `recording.became_available` when liveness succeeds. If that check does not
        confirm liveness, the room Recording remains active and no
        `recording.failed` webhook is emitted. A later stop emits
        `recording.ended`.
      tags:
        - roomPlayback
      parameters:
        - name: room_id
          in: path
          description: |-
            [Room](/api/rooms) ID
            (format `{prefix}-room-{uuid}`). The UUID portion is lowercase
            hexadecimal — uppercase hex is rejected with 400.
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>`. See
            [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional client-generated key for a mutating endpoint. It identifies one method, route, query, content type,
            and exact raw body within the authenticated app. Reusing it for a different request returns 422. While its
            record exists, a retry replays the original accepted response when available. Keys are valid for 1 hour.
            Allowed characters: letters, digits, dot, hyphen, underscore; max 128 characters. See the Idempotency guide.
          required: false
          schema:
            type: string
      responses:
        '202':
          description: Room recording start accepted
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Room Playback_startRoomRecording_Response_202'
        '400':
          description: >-
            Missing `Authorization`, malformed Bearer credentials, or invalid request parameters. A syntactically valid
            credential with an invalid API key returns `401` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StartRoomRecordingRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StartRoomRecordingRequestUnauthorizedError'
        '404':
          description: Room not found, including a room owned by another app
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StartRoomRecordingRequestNotFoundError'
        '409':
          description: |-
            The same `Idempotency-Key` is already in progress, the room media
            lifecycle is busy, the room is closing, or recording is already
            active. All cases use the standard error envelope with
            `code: conflict`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StartRoomRecordingRequestConflictError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different request body. A key maps to one request; use a new key.
            See the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StartRoomRecordingRequestUnprocessableEntityError'
        '429':
          description: >-
            Rate limit exceeded — a per-command, per-room, or per-app token bucket was empty. The `retry_after` field
            gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StartRoomRecordingRequestTooManyRequestsError'
        '500':
          description: Internal gateway error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StartRoomRecordingRequestInternalServerError'
        '503':
          description: |-
            The recording service, the room source node, or the idempotency
            store is unavailable. An idempotency-store outage means the request
            was not processed; retry with the same key.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StartRoomRecordingRequestServiceUnavailableError'
  /api/v1/rooms/{room_id}/playback/record/stop:
    post:
      operationId: stopRoomRecording
      summary: Stop recording room audio
      description: |-
        Stop the active room [Recording](/api/recording). The accepted
        [Operation](/api) and the same Recording identity are returned in
        one flat response. If the room has no active Recording, the request
        returns `409 recording_not_active` without dispatching a recording
        command or emitting an event. This operation is not wrapped by
        `Idempotency-Key` middleware.

        **Triggered webhook:** `recording.ended`, carrying a fresh signed public
        URL for the same `recording_uuid`. No post-stop reachability probe is
        performed.
      tags:
        - roomPlayback
      parameters:
        - name: room_id
          in: path
          description: |-
            [Room](/api/rooms) ID
            (format `{prefix}-room-{uuid}`). The UUID portion is lowercase
            hexadecimal — uppercase hex is rejected with 400.
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>`. See
            [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for details.
          required: true
          schema:
            type: string
      responses:
        '202':
          description: Room recording stop accepted
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Room Playback_stopRoomRecording_Response_202'
        '400':
          description: >-
            Missing `Authorization`, malformed Bearer credentials, or invalid request parameters. A syntactically valid
            credential with an invalid API key returns `401` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StopRoomRecordingRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StopRoomRecordingRequestUnauthorizedError'
        '404':
          description: Room not found, including a room owned by another app
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StopRoomRecordingRequestNotFoundError'
        '409':
          description: The room has no active Recording; no command or event is produced.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StopRoomRecordingRequestConflictError'
        '429':
          description: >-
            Rate limit exceeded — a per-command, per-room, or per-app token bucket was empty. The `retry_after` field
            gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StopRoomRecordingRequestTooManyRequestsError'
        '500':
          description: Internal gateway error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StopRoomRecordingRequestInternalServerError'
        '503':
          description: The room source node is unavailable, so no stop was dispatched.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StopRoomRecordingRequestServiceUnavailableError'
  /api/v1/rooms/{room_id}/playback/seek:
    post:
      operationId: seekRoomPlayback
      summary: Seek room playback
      description: |-
        **Rate limit: Per room** · **Burst:** 15 · **Refill:** 10 req/s

        Shared by room playback seek commands (the `room.playback.seek` bucket).

        Seek the room's current playback by a relative, signed offset.
        `seek_ms` is a step applied to the current position: positive =
        forward; a negative value rewinds. It must be non-zero — a value of `0` is
        rejected.
        Validated identically to the session-scoped
        `POST /v1/sessions/{uuid}/playback/seek`.

        Accepts an optional `Idempotency-Key` header.

        Returns `202` with `{operation_uuid, status: "in_progress"}`.
      tags:
        - roomPlayback
      parameters:
        - name: room_id
          in: path
          description: |-
            [Room](/api/rooms) ID
            (format `{prefix}-room-{uuid}`). The UUID portion is lowercase
            hexadecimal — uppercase hex is rejected with 400.
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>`. See
            [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional client-generated key for a mutating endpoint. It identifies one method, route, query, content type,
            and exact raw body within the authenticated app. Reusing it for a different request returns 422. While its
            record exists, a retry replays the original accepted response when available. Keys are valid for 1 hour.
            Allowed characters: letters, digits, dot, hyphen, underscore; max 128 characters. See the Idempotency guide.
          required: false
          schema:
            type: string
      responses:
        '202':
          description: Room playback command accepted for asynchronous execution
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RoomAsyncCommandResponse'
        '400':
          description: >-
            Missing `Authorization`, malformed Bearer credentials, or invalid request parameters. A syntactically valid
            credential with an invalid API key returns `401` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SeekRoomPlaybackRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SeekRoomPlaybackRequestUnauthorizedError'
        '404':
          description: Room not found
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SeekRoomPlaybackRequestNotFoundError'
        '409':
          description: >-
            The request cannot be completed because of state conflict — typically the session is terminating, or the
            resource (room, recording) is in a state incompatible with this command. On an operation that accepts
            `Idempotency-Key`, this status can also mean the original request with that key is still in progress; wait
            for its result rather than sending a different request with the same key.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SeekRoomPlaybackRequestConflictError'
        '413':
          description: Request body exceeds the endpoint's size limit.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SeekRoomPlaybackRequestContentTooLargeError'
        '415':
          description: 'A request with a JSON body must use `Content-Type: application/json`.'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SeekRoomPlaybackRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different request body. A key maps to one request; use a new key.
            See the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SeekRoomPlaybackRequestUnprocessableEntityError'
        '429':
          description: >-
            Rate limit exceeded — a per-command, per-room, or per-app token bucket was empty. The `retry_after` field
            gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SeekRoomPlaybackRequestTooManyRequestsError'
        '500':
          description: Internal gateway error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SeekRoomPlaybackRequestInternalServerError'
        '503':
          description: >-
            When an `Idempotency-Key` was supplied, the idempotency store is unavailable and the request was NOT
            processed; retry with the same key. Some operations can also return `503` for an unavailable room/session
            source or another documented dependency even when no key was supplied; in that case this response does not
            imply idempotency-store failure. See the operation description and the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SeekRoomPlaybackRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties:
                seek_ms:
                  type: integer
                  description: |-
                    Relative seek offset in milliseconds. Positive = forward,
                    a negative value rewinds. Must be non-zero.
              required:
                - seek_ms
  /api/v1/rooms/{room_id}/playback/stop:
    post:
      operationId: stopRoomPlayback
      summary: Stop room playback
      description: >-
        Stop all room playback.


        **Triggered webhooks:** `command.room.playback.stop.accepted` (immediate) and `room.playback.ended` with
        `reason: stopped` (terminal for the interrupted playback)
      tags:
        - roomPlayback
      parameters:
        - name: room_id
          in: path
          description: |-
            [Room](/api/rooms) ID
            (format `{prefix}-room-{uuid}`). The UUID portion is lowercase
            hexadecimal — uppercase hex is rejected with 400.
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>`. See
            [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for details.
          required: true
          schema:
            type: string
      responses:
        '202':
          description: Room playback command accepted for asynchronous execution
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RoomAsyncCommandResponse'
        '400':
          description: >-
            Missing `Authorization`, malformed Bearer credentials, or invalid request parameters. A syntactically valid
            credential with an invalid API key returns `401` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StopRoomPlaybackRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StopRoomPlaybackRequestUnauthorizedError'
        '404':
          description: Room not found
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StopRoomPlaybackRequestNotFoundError'
        '409':
          description: A room playback transition is already in progress; retry after it settles.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StopRoomPlaybackRequestConflictError'
        '429':
          description: >-
            Rate limit exceeded — a per-command, per-room, or per-app token bucket was empty. The `retry_after` field
            gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StopRoomPlaybackRequestTooManyRequestsError'
        '500':
          description: Internal gateway error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StopRoomPlaybackRequestInternalServerError'
        '503':
          description: The room source node is unavailable, or the stop could not be confirmed; no stop was accepted.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StopRoomPlaybackRequestServiceUnavailableError'
  /api/v1/rooms/{room_id}/playback/volume:
    post:
      operationId: setRoomVolume
      summary: Set room playback volume
      description: |-
        Adjust room playback volume on a 0-200 scale: 100 = normal/unchanged
        (default), 0 = mute, values above 100 boost up to a maximum of 200. This is
        relative gain, not target loudness — 100 leaves the file as recorded (a quiet
        file at 100 stays quiet); there is no automatic loudness matching across files.

        **Triggered webhooks:** `command.room.playback.volume.accepted` (immediate)
      tags:
        - roomPlayback
      parameters:
        - name: room_id
          in: path
          description: |-
            [Room](/api/rooms) ID
            (format `{prefix}-room-{uuid}`). The UUID portion is lowercase
            hexadecimal — uppercase hex is rejected with 400.
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>`. See
            [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional client-generated key for a mutating endpoint. It identifies one method, route, query, content type,
            and exact raw body within the authenticated app. Reusing it for a different request returns 422. While its
            record exists, a retry replays the original accepted response when available. Keys are valid for 1 hour.
            Allowed characters: letters, digits, dot, hyphen, underscore; max 128 characters. See the Idempotency guide.
          required: false
          schema:
            type: string
      responses:
        '202':
          description: Room playback command accepted for asynchronous execution
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RoomAsyncCommandResponse'
        '400':
          description: >-
            Missing `Authorization`, malformed Bearer credentials, or invalid request parameters. A syntactically valid
            credential with an invalid API key returns `401` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SetRoomVolumeRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SetRoomVolumeRequestUnauthorizedError'
        '404':
          description: Room not found
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SetRoomVolumeRequestNotFoundError'
        '409':
          description: >-
            A request with this `Idempotency-Key` is already in progress. Wait for its result instead of re-sending. See
            the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SetRoomVolumeRequestConflictError'
        '413':
          description: Request body exceeds the endpoint's size limit.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SetRoomVolumeRequestContentTooLargeError'
        '415':
          description: 'A request with a JSON body must use `Content-Type: application/json`.'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SetRoomVolumeRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different request body. A key maps to one request; use a new key.
            See the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SetRoomVolumeRequestUnprocessableEntityError'
        '429':
          description: >-
            Rate limit exceeded — a per-command, per-room, or per-app token bucket was empty. The `retry_after` field
            gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SetRoomVolumeRequestTooManyRequestsError'
        '500':
          description: Internal gateway error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SetRoomVolumeRequestInternalServerError'
        '503':
          description: >-
            When an `Idempotency-Key` was supplied, the idempotency store is unavailable and the request was NOT
            processed; retry with the same key. Some operations can also return `503` for an unavailable room/session
            source or another documented dependency even when no key was supplied; in that case this response does not
            imply idempotency-store failure. See the operation description and the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SetRoomVolumeRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties:
                volume:
                  type: integer
                  description: Playback volume (0-200). 100 = normal/unchanged, 0 = mute, above 100 boosts up to 200.
              required:
                - volume
  /v1/sessions/{uuid}/recording/mask:
    post:
      operationId: maskRecording
      summary: Mask (pause writing) the active recording
      description: |-
        **Rate limit: Per command** · **Burst:** 20 · **Refill:** 20 req/s

        Shares the `seek` bucket.

        Temporarily stop writing audio into the active recording (e.g. to redact a
        card-number segment). The recording stays running; only the masked window is
        omitted. Resume with `recording/unmask`.

        Requires an active recording on the session; returns `409 Conflict` if none is
        in progress (the call is unaffected).

        **Triggered webhooks:**
        - `command.recording.mask.accepted` (immediate; carries this response's `operation_uuid`)
      tags:
        - recording
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) UUID (format `{5-char-prefix}-{uuid}`).'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>`. See
            [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional client-generated key for a mutating endpoint. It identifies one method, route, query, content type,
            and exact raw body within the authenticated app. Reusing it for a different request returns 422. While its
            record exists, a retry replays the original accepted response when available. Keys are valid for 1 hour.
            Allowed characters: letters, digits, dot, hyphen, underscore; max 128 characters. See the Idempotency guide.
          required: false
          schema:
            type: string
      responses:
        '202':
          description: Command accepted for async execution
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AsyncCommandResponse'
        '400':
          description: >-
            Missing `Authorization`, malformed Bearer credentials, or invalid request parameters. A syntactically valid
            credential with an invalid API key returns `401` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/MaskRecordingRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/MaskRecordingRequestUnauthorizedError'
        '404':
          description: The requested resource was not found or is not owned by the authenticated app.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/MaskRecordingRequestNotFoundError'
        '409':
          description: >-
            The request cannot be completed because of state conflict — typically the session is terminating, or the
            resource (room, recording) is in a state incompatible with this command. On an operation that accepts
            `Idempotency-Key`, this status can also mean the original request with that key is still in progress; wait
            for its result rather than sending a different request with the same key.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/MaskRecordingRequestConflictError'
        '413':
          description: Request body exceeds the endpoint's size limit.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/MaskRecordingRequestContentTooLargeError'
        '415':
          description: 'A request with a JSON body must use `Content-Type: application/json`.'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/MaskRecordingRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different request body. A key maps to one request; use a new key.
            See the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/MaskRecordingRequestUnprocessableEntityError'
        '429':
          description: >-
            Rate limit exceeded — a per-command, per-room, or per-app token bucket was empty. The `retry_after` field
            gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/MaskRecordingRequestTooManyRequestsError'
        '500':
          description: Internal gateway error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/MaskRecordingRequestInternalServerError'
        '503':
          description: >-
            When an `Idempotency-Key` was supplied, the idempotency store is unavailable and the request was NOT
            processed; retry with the same key. Some operations can also return `503` for an unavailable room/session
            source or another documented dependency even when no key was supplied; in that case this response does not
            imply idempotency-store failure. See the operation description and the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/MaskRecordingRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/CommandRequest'
  /v1/sessions/{uuid}/recording/start:
    post:
      operationId: startRecording
      summary: Start recording
      description: >-
        **Rate limit: Per command** · **Burst:** 4 · **Refill:** 1 req/s


        Start a [Recording](/api/recording) of the call via the gateway recording

        service. The accepted [Operation](/api) is returned immediately;

        use its `operation_uuid` to correlate the command lifecycle. Once

        `command.recording.start.accepted` supplies `recording_uuid`, use that

        identifier to correlate the Recording's complete webhook lifecycle.

        Requires recording to be enabled on this gateway. Each request opens a stream, and recording normally starts
        once per call.


        Output is 8 kHz mono mixed WAV (both legs combined). Format is not configurable.


        **Triggered webhooks:**

        - `command.recording.start.accepted` (immediate, when recording begins; carries
          `recording_uuid`, the signed public `pull_url`, and the
          `operation_uuid` of this `recording/start` command). Actual
          recording errors surface later as `recording.failed`.
        - `recording.became_available` (once the gateway confirms the recording is
          durably ingested; carries the explicit `pull_url` and `live_url`
          signed links) — or `recording.failed` if it never confirms within
          the validation window.
        - When `enable_voice_activity_events` is true,
          `recording.speech.started` and `recording.speech.ended` report
          customer speech transitions for the lifetime of this recording.
          Sensitivity and speech/silence confirmation durations are configurable.

        The signed `pull_url` carried by `command.recording.start.accepted` is immediately

        fetchable — the recording can be streamed while it is still in progress.

        `pull_url` fetches the whole recording so far.

        Treat the complete URL as an opaque, time-bounded bearer capability and

        use it exactly as emitted; do not construct, parse, or modify its host,

        path, or token. Its default 24-hour window starts when

        `command.recording.start.accepted` is emitted, not when recording stops.
      tags:
        - recording
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) UUID (format `{5-char-prefix}-{uuid}`).'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>`. See
            [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional client-generated key for a mutating endpoint. It identifies one method, route, query, content type,
            and exact raw body within the authenticated app. Reusing it for a different request returns 422. While its
            record exists, a retry replays the original accepted response when available. Keys are valid for 1 hour.
            Allowed characters: letters, digits, dot, hyphen, underscore; max 128 characters. See the Idempotency guide.
          required: false
          schema:
            type: string
      responses:
        '202':
          description: Command accepted for async execution
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AsyncCommandResponse'
        '400':
          description: >-
            Missing `Authorization`, malformed Bearer credentials, or invalid request parameters. A syntactically valid
            credential with an invalid API key returns `401` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StartRecordingRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StartRecordingRequestUnauthorizedError'
        '404':
          description: The requested resource was not found or is not owned by the authenticated app.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StartRecordingRequestNotFoundError'
        '409':
          description: >-
            The request cannot be completed because of state conflict — typically the session is terminating, or the
            resource (room, recording) is in a state incompatible with this command. On an operation that accepts
            `Idempotency-Key`, this status can also mean the original request with that key is still in progress; wait
            for its result rather than sending a different request with the same key.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StartRecordingRequestConflictError'
        '413':
          description: Request body exceeds the endpoint's size limit.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StartRecordingRequestContentTooLargeError'
        '415':
          description: 'A request with a JSON body must use `Content-Type: application/json`.'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StartRecordingRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different request body. A key maps to one request; use a new key.
            See the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StartRecordingRequestUnprocessableEntityError'
        '429':
          description: >-
            Rate limit exceeded — a per-command, per-room, or per-app token bucket was empty. The `retry_after` field
            gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StartRecordingRequestTooManyRequestsError'
        '500':
          description: Internal gateway error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StartRecordingRequestInternalServerError'
        '503':
          description: |-
            Recording is not enabled on this gateway, or an `Idempotency-Key`
            was supplied and its store is unavailable. In either case no
            recording side effect is started and no webhook is emitted; retry
            an idempotency-store outage with the same key.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StartRecordingRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties:
                operation_uuid:
                  type: string
                  format: uuid
                  description: >-
                    Optional caller-supplied per-command correlation id, a bare lowercase RFC-4122 v4 UUID (no prefix).
                    Echoed back as `operation_uuid` in the 202 ack. A later lifecycle webhook carries it only when the
                    gateway can unambiguously associate that event with this command; the field is correlation, not
                    proof of causation. When omitted, the gateway mints one. Not an idempotency key — request
                    deduplication is the `Idempotency-Key` header. Invalid input (not a v4 UUID) is rejected with `400
                    invalid_request`.
                enable_voice_activity_events:
                  type: boolean
                  default: false
                  description: |-
                    When true, emit `recording.speech.started` and
                    `recording.speech.ended` while this session recording is
                    active. Detection is passive and does not alter recorded audio.
                    Not supported for standalone `type: ws` sessions or room recordings.
                voice_activity_config:
                  $ref: >-
                    #/components/schemas/V1SessionsUuidRecordingStartPostRequestBodyContentApplicationJsonSchemaVoiceActivityConfig
                  description: |-
                    Required tuning when voice activity events are enabled. Supplying
                    this object requires
                    `enable_voice_activity_events: true`; otherwise the request is
                    rejected.
  /v1/sessions/{uuid}/recording/stop:
    post:
      operationId: stopRecording
      summary: Stop recording
      description: |-
        **Rate limit: Per command** · **Burst:** 20 · **Refill:** 20 req/s

        Stop the active [Recording](/api/recording). The accepted
        [Operation](/api) is returned immediately.

        This bucket's high capacity lets a DTMF terminator press right after the
        recording-start beep end the recording without sharing
        `recording/start`'s independent bucket.

        **Triggered webhook:** `recording.ended` is emitted when stop is accepted;
        it carries `recording_uuid`, the signed public `pull_url`, the
        `operation_uuid` of the originating `recording/start` command, and `duration`.
        There is no post-stop reachability probe. A `recording.failed` emitted
        earlier because the start-liveness check timed out can coexist with this
        later `recording.ended`; consumers must not treat those events as mutually
        exclusive.

        The signed `pull_url` carried by `recording.ended` gets a fresh
        validity window at that event's emission (24 hours by default).
        After completion it supports HTTP Range requests. Treat the complete
        URL as opaque and use it exactly as emitted.
      tags:
        - recording
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) UUID (format `{5-char-prefix}-{uuid}`).'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>`. See
            [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional client-generated key for a mutating endpoint. It identifies one method, route, query, content type,
            and exact raw body within the authenticated app. Reusing it for a different request returns 422. While its
            record exists, a retry replays the original accepted response when available. Keys are valid for 1 hour.
            Allowed characters: letters, digits, dot, hyphen, underscore; max 128 characters. See the Idempotency guide.
          required: false
          schema:
            type: string
      responses:
        '202':
          description: Command accepted for async execution
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AsyncCommandResponse'
        '400':
          description: >-
            Missing `Authorization`, malformed Bearer credentials, or invalid request parameters. A syntactically valid
            credential with an invalid API key returns `401` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StopRecordingRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StopRecordingRequestUnauthorizedError'
        '404':
          description: The requested resource was not found or is not owned by the authenticated app.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StopRecordingRequestNotFoundError'
        '409':
          description: >-
            The request cannot be completed because of state conflict — typically the session is terminating, or the
            resource (room, recording) is in a state incompatible with this command. On an operation that accepts
            `Idempotency-Key`, this status can also mean the original request with that key is still in progress; wait
            for its result rather than sending a different request with the same key.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StopRecordingRequestConflictError'
        '413':
          description: Request body exceeds the endpoint's size limit.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StopRecordingRequestContentTooLargeError'
        '415':
          description: 'A request with a JSON body must use `Content-Type: application/json`.'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StopRecordingRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different request body. A key maps to one request; use a new key.
            See the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StopRecordingRequestUnprocessableEntityError'
        '429':
          description: >-
            Rate limit exceeded — a per-command, per-room, or per-app token bucket was empty. The `retry_after` field
            gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StopRecordingRequestTooManyRequestsError'
        '500':
          description: Internal gateway error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StopRecordingRequestInternalServerError'
        '503':
          description: >-
            When an `Idempotency-Key` was supplied, the idempotency store is unavailable and the request was NOT
            processed; retry with the same key. Some operations can also return `503` for an unavailable room/session
            source or another documented dependency even when no key was supplied; in that case this response does not
            imply idempotency-store failure. See the operation description and the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StopRecordingRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/CommandRequest'
  /v1/sessions/{uuid}/recording/unmask:
    post:
      operationId: unmaskRecording
      summary: Unmask (resume writing) the active recording
      description: |-
        **Rate limit: Per command** · **Burst:** 20 · **Refill:** 20 req/s

        Shares the `seek` bucket.

        Resume writing audio into the active recording after a `recording/mask`. The
        recording continues uninterrupted. Calling unmask when not masked is harmless.

        Requires an active recording on the session; returns `409 Conflict` if none is
        in progress (the call is unaffected).

        **Triggered webhooks:**
        - `command.recording.unmask.accepted` (immediate; carries this response's `operation_uuid`)
      tags:
        - recording
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) UUID (format `{5-char-prefix}-{uuid}`).'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>`. See
            [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional client-generated key for a mutating endpoint. It identifies one method, route, query, content type,
            and exact raw body within the authenticated app. Reusing it for a different request returns 422. While its
            record exists, a retry replays the original accepted response when available. Keys are valid for 1 hour.
            Allowed characters: letters, digits, dot, hyphen, underscore; max 128 characters. See the Idempotency guide.
          required: false
          schema:
            type: string
      responses:
        '202':
          description: Command accepted for async execution
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AsyncCommandResponse'
        '400':
          description: >-
            Missing `Authorization`, malformed Bearer credentials, or invalid request parameters. A syntactically valid
            credential with an invalid API key returns `401` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UnmaskRecordingRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UnmaskRecordingRequestUnauthorizedError'
        '404':
          description: The requested resource was not found or is not owned by the authenticated app.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UnmaskRecordingRequestNotFoundError'
        '409':
          description: >-
            The request cannot be completed because of state conflict — typically the session is terminating, or the
            resource (room, recording) is in a state incompatible with this command. On an operation that accepts
            `Idempotency-Key`, this status can also mean the original request with that key is still in progress; wait
            for its result rather than sending a different request with the same key.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UnmaskRecordingRequestConflictError'
        '413':
          description: Request body exceeds the endpoint's size limit.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UnmaskRecordingRequestContentTooLargeError'
        '415':
          description: 'A request with a JSON body must use `Content-Type: application/json`.'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UnmaskRecordingRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different request body. A key maps to one request; use a new key.
            See the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UnmaskRecordingRequestUnprocessableEntityError'
        '429':
          description: >-
            Rate limit exceeded — a per-command, per-room, or per-app token bucket was empty. The `retry_after` field
            gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UnmaskRecordingRequestTooManyRequestsError'
        '500':
          description: Internal gateway error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UnmaskRecordingRequestInternalServerError'
        '503':
          description: >-
            When an `Idempotency-Key` was supplied, the idempotency store is unavailable and the request was NOT
            processed; retry with the same key. Some operations can also return `503` for an unavailable room/session
            source or another documented dependency even when no key was supplied; in that case this response does not
            imply idempotency-store failure. See the operation description and the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UnmaskRecordingRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/CommandRequest'
  /v1/sessions/{uuid}/websocket/flush:
    post:
      operationId: wsFlush
      summary: Flush buffered playback
      description: |-
        Discard any audio currently buffered for playback from the backend.
        This is the barge-in control: when the user interrupts an AI response,
        flush the queued backend audio so stale response audio stops before the
        backend sends the new response. It flushes the backend-audio playback
        buffer, not the WebSocket connection or inbound user audio. Works on
        both a per-call relay and a standalone `ws` session.

        **Triggered webhooks:** `command.websocket.flush.accepted`
      tags:
        - webSocket
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) UUID (format `{5-char-prefix}-{uuid}`).'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>`. See
            [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional client-generated key for a mutating endpoint. It identifies one method, route, query, content type,
            and exact raw body within the authenticated app. Reusing it for a different request returns 422. While its
            record exists, a retry replays the original accepted response when available. Keys are valid for 1 hour.
            Allowed characters: letters, digits, dot, hyphen, underscore; max 128 characters. See the Idempotency guide.
          required: false
          schema:
            type: string
      responses:
        '202':
          description: Command accepted for async execution
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AsyncCommandResponse'
        '400':
          description: >-
            Missing `Authorization`, malformed Bearer credentials, or invalid request parameters. A syntactically valid
            credential with an invalid API key returns `401` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsFlushRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsFlushRequestUnauthorizedError'
        '404':
          description: >-
            Session not found. A session owned by a *different* application returns this same `404` (never a `403`) so
            the response cannot be used to probe for the existence of another tenant's session.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsFlushRequestNotFoundError'
        '409':
          description: >-
            The request cannot be completed because of state conflict — typically the session is terminating, or the
            resource (room, recording) is in a state incompatible with this command. On an operation that accepts
            `Idempotency-Key`, this status can also mean the original request with that key is still in progress; wait
            for its result rather than sending a different request with the same key.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsFlushRequestConflictError'
        '413':
          description: Request body exceeds the endpoint's size limit.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsFlushRequestContentTooLargeError'
        '415':
          description: 'A request with a JSON body must use `Content-Type: application/json`.'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsFlushRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different request body. A key maps to one request; use a new key.
            See the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsFlushRequestUnprocessableEntityError'
        '429':
          description: >-
            Rate limit exceeded — a per-command, per-room, or per-app token bucket was empty. The `retry_after` field
            gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsFlushRequestTooManyRequestsError'
        '500':
          description: Internal gateway error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsFlushRequestInternalServerError'
        '503':
          description: >-
            When an `Idempotency-Key` was supplied, the idempotency store is unavailable and the request was NOT
            processed; retry with the same key. Some operations can also return `503` for an unavailable room/session
            source or another documented dependency even when no key was supplied; in that case this response does not
            imply idempotency-store failure. See the operation description and the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsFlushRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/CommandRequest'
  /v1/sessions/{uuid}/websocket/mute:
    post:
      operationId: wsMute
      summary: Mute a relay leg
      description: |-
        Mute audio in one direction of the relay. Works on both a per-call relay
        and a standalone `ws` session.

        **Triggered webhooks:** `command.websocket.mute.accepted`
      tags:
        - webSocket
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) UUID (format `{5-char-prefix}-{uuid}`).'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>`. See
            [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional client-generated key for a mutating endpoint. It identifies one method, route, query, content type,
            and exact raw body within the authenticated app. Reusing it for a different request returns 422. While its
            record exists, a retry replays the original accepted response when available. Keys are valid for 1 hour.
            Allowed characters: letters, digits, dot, hyphen, underscore; max 128 characters. See the Idempotency guide.
          required: false
          schema:
            type: string
      responses:
        '202':
          description: Command accepted for async execution
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AsyncCommandResponse'
        '400':
          description: >-
            Missing `Authorization`, malformed Bearer credentials, or invalid request parameters. A syntactically valid
            credential with an invalid API key returns `401` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsMuteRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsMuteRequestUnauthorizedError'
        '404':
          description: >-
            Session not found. A session owned by a *different* application returns this same `404` (never a `403`) so
            the response cannot be used to probe for the existence of another tenant's session.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsMuteRequestNotFoundError'
        '409':
          description: >-
            The request cannot be completed because of state conflict — typically the session is terminating, or the
            resource (room, recording) is in a state incompatible with this command. On an operation that accepts
            `Idempotency-Key`, this status can also mean the original request with that key is still in progress; wait
            for its result rather than sending a different request with the same key.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsMuteRequestConflictError'
        '413':
          description: Request body exceeds the endpoint's size limit.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsMuteRequestContentTooLargeError'
        '415':
          description: 'A request with a JSON body must use `Content-Type: application/json`.'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsMuteRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different request body. A key maps to one request; use a new key.
            See the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsMuteRequestUnprocessableEntityError'
        '429':
          description: >-
            Rate limit exceeded — a per-command, per-room, or per-app token bucket was empty. The `retry_after` field
            gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsMuteRequestTooManyRequestsError'
        '500':
          description: Internal gateway error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsMuteRequestInternalServerError'
        '503':
          description: >-
            When an `Idempotency-Key` was supplied, the idempotency store is unavailable and the request was NOT
            processed; retry with the same key. Some operations can also return `503` for an unavailable room/session
            source or another documented dependency even when no key was supplied; in that case this response does not
            imply idempotency-store failure. See the operation description and the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsMuteRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties:
                operation_uuid:
                  type: string
                  format: uuid
                  description: >-
                    Optional caller-supplied per-command correlation id, a bare lowercase RFC-4122 v4 UUID (no prefix).
                    Echoed back as `operation_uuid` in the 202 ack. A later lifecycle webhook carries it only when the
                    gateway can unambiguously associate that event with this command; the field is correlation, not
                    proof of causation. When omitted, the gateway mints one. Not an idempotency key — request
                    deduplication is the `Idempotency-Key` header. Invalid input (not a v4 UUID) is rejected with `400
                    invalid_request`.
                leg:
                  $ref: '#/components/schemas/V1SessionsUuidWebsocketMutePostRequestBodyContentApplicationJsonSchemaLeg'
                  description: |-
                    Which direction the mute/unmute applies to: `user` (audio from the
                    caller), `backend` (audio from the backend), or `all`.
              required:
                - leg
  /v1/sessions/{uuid}/websocket/pause:
    post:
      operationId: wsPause
      summary: Pause the relay
      description: |-
        Temporarily pause audio in both directions while keeping the relay connected. This stops
        sending the user's audio to the backend and stops playing backend audio to the session.
        Pausing does not flush buffered backend audio. Works on both a per-call relay and a
        standalone `ws` session.

        **Triggered webhooks:** `command.websocket.pause.accepted`
      tags:
        - webSocket
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) UUID (format `{5-char-prefix}-{uuid}`).'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>`. See
            [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional client-generated key for a mutating endpoint. It identifies one method, route, query, content type,
            and exact raw body within the authenticated app. Reusing it for a different request returns 422. While its
            record exists, a retry replays the original accepted response when available. Keys are valid for 1 hour.
            Allowed characters: letters, digits, dot, hyphen, underscore; max 128 characters. See the Idempotency guide.
          required: false
          schema:
            type: string
      responses:
        '202':
          description: Command accepted for async execution
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AsyncCommandResponse'
        '400':
          description: >-
            Missing `Authorization`, malformed Bearer credentials, or invalid request parameters. A syntactically valid
            credential with an invalid API key returns `401` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsPauseRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsPauseRequestUnauthorizedError'
        '404':
          description: >-
            Session not found. A session owned by a *different* application returns this same `404` (never a `403`) so
            the response cannot be used to probe for the existence of another tenant's session.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsPauseRequestNotFoundError'
        '409':
          description: >-
            The request cannot be completed because of state conflict — typically the session is terminating, or the
            resource (room, recording) is in a state incompatible with this command. On an operation that accepts
            `Idempotency-Key`, this status can also mean the original request with that key is still in progress; wait
            for its result rather than sending a different request with the same key.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsPauseRequestConflictError'
        '413':
          description: Request body exceeds the endpoint's size limit.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsPauseRequestContentTooLargeError'
        '415':
          description: 'A request with a JSON body must use `Content-Type: application/json`.'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsPauseRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different request body. A key maps to one request; use a new key.
            See the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsPauseRequestUnprocessableEntityError'
        '429':
          description: >-
            Rate limit exceeded — a per-command, per-room, or per-app token bucket was empty. The `retry_after` field
            gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsPauseRequestTooManyRequestsError'
        '500':
          description: Internal gateway error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsPauseRequestInternalServerError'
        '503':
          description: >-
            When an `Idempotency-Key` was supplied, the idempotency store is unavailable and the request was NOT
            processed; retry with the same key. Some operations can also return `503` for an unavailable room/session
            source or another documented dependency even when no key was supplied; in that case this response does not
            imply idempotency-store failure. See the operation description and the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsPauseRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/CommandRequest'
  /v1/sessions/{uuid}/websocket/resume:
    post:
      operationId: wsResume
      summary: Resume the relay
      description: |-
        Resume audio in both directions after a pause. This does not unmute either leg; mute
        settings applied before or during the pause remain in effect. Works on both a per-call
        relay and a standalone `ws` session.

        **Triggered webhooks:** `command.websocket.resume.accepted`
      tags:
        - webSocket
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) UUID (format `{5-char-prefix}-{uuid}`).'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>`. See
            [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional client-generated key for a mutating endpoint. It identifies one method, route, query, content type,
            and exact raw body within the authenticated app. Reusing it for a different request returns 422. While its
            record exists, a retry replays the original accepted response when available. Keys are valid for 1 hour.
            Allowed characters: letters, digits, dot, hyphen, underscore; max 128 characters. See the Idempotency guide.
          required: false
          schema:
            type: string
      responses:
        '202':
          description: Command accepted for async execution
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AsyncCommandResponse'
        '400':
          description: >-
            Missing `Authorization`, malformed Bearer credentials, or invalid request parameters. A syntactically valid
            credential with an invalid API key returns `401` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsResumeRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsResumeRequestUnauthorizedError'
        '404':
          description: >-
            Session not found. A session owned by a *different* application returns this same `404` (never a `403`) so
            the response cannot be used to probe for the existence of another tenant's session.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsResumeRequestNotFoundError'
        '409':
          description: >-
            The request cannot be completed because of state conflict — typically the session is terminating, or the
            resource (room, recording) is in a state incompatible with this command. On an operation that accepts
            `Idempotency-Key`, this status can also mean the original request with that key is still in progress; wait
            for its result rather than sending a different request with the same key.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsResumeRequestConflictError'
        '413':
          description: Request body exceeds the endpoint's size limit.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsResumeRequestContentTooLargeError'
        '415':
          description: 'A request with a JSON body must use `Content-Type: application/json`.'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsResumeRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different request body. A key maps to one request; use a new key.
            See the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsResumeRequestUnprocessableEntityError'
        '429':
          description: >-
            Rate limit exceeded — a per-command, per-room, or per-app token bucket was empty. The `retry_after` field
            gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsResumeRequestTooManyRequestsError'
        '500':
          description: Internal gateway error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsResumeRequestInternalServerError'
        '503':
          description: >-
            When an `Idempotency-Key` was supplied, the idempotency store is unavailable and the request was NOT
            processed; retry with the same key. Some operations can also return `503` for an unavailable room/session
            source or another documented dependency even when no key was supplied; in that case this response does not
            imply idempotency-store failure. See the operation description and the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsResumeRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/CommandRequest'
  /v1/sessions/{uuid}/websocket/start:
    post:
      operationId: wsStart
      summary: Start a WebSocket audio relay
      description: |-
        Attach a live, bidirectional audio relay between this session and an
        external WebSocket backend. Audio streams both ways for the life of the
        relay. Only one relay may be active per session at a time — starting a
        second returns `409`. Asynchronous command; outcomes arrive as `websocket.*`
        webhook events.

        **Triggered webhooks:** `websocket.connected`, `websocket.disconnected`,
        `websocket.failed`, `websocket.message_received`,
        `websocket.audio_playback_completed`
      tags:
        - webSocket
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) UUID (format `{5-char-prefix}-{uuid}`).'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>`. See
            [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional client-generated key for a mutating endpoint. It identifies one method, route, query, content type,
            and exact raw body within the authenticated app. Reusing it for a different request returns 422. While its
            record exists, a retry replays the original accepted response when available. Keys are valid for 1 hour.
            Allowed characters: letters, digits, dot, hyphen, underscore; max 128 characters. See the Idempotency guide.
          required: false
          schema:
            type: string
      responses:
        '202':
          description: Command accepted for async execution
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AsyncCommandResponse'
        '400':
          description: >-
            Missing `Authorization`, malformed Bearer credentials, or invalid request parameters. A syntactically valid
            credential with an invalid API key returns `401` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsStartRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsStartRequestUnauthorizedError'
        '404':
          description: >-
            Session not found. A session owned by a *different* application returns this same `404` (never a `403`) so
            the response cannot be used to probe for the existence of another tenant's session.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsStartRequestNotFoundError'
        '409':
          description: |-
            A relay is already active on this session, or a request with this
            `Idempotency-Key` is already in progress.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsStartRequestConflictError'
        '413':
          description: Request body exceeds the endpoint's size limit.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsStartRequestContentTooLargeError'
        '415':
          description: 'A request with a JSON body must use `Content-Type: application/json`.'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsStartRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different request body. A key maps to one request; use a new key.
            See the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsStartRequestUnprocessableEntityError'
        '429':
          description: >-
            Rate limit exceeded — a per-command, per-room, or per-app token bucket was empty. The `retry_after` field
            gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsStartRequestTooManyRequestsError'
        '500':
          description: Internal gateway error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsStartRequestInternalServerError'
        '503':
          description: >-
            When an `Idempotency-Key` was supplied, the idempotency store is unavailable and the request was NOT
            processed; retry with the same key. Some operations can also return `503` for an unavailable room/session
            source or another documented dependency even when no key was supplied; in that case this response does not
            imply idempotency-store failure. See the operation description and the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsStartRequestServiceUnavailableError'
      requestBody:
        description: |-
          WebSocket audio relay configuration. Shared by the `ws/start` command and
          the `ws` block of `POST /v1/sessions`.
        content:
          application/json:
            schema:
              type: object
              properties:
                operation_uuid:
                  type: string
                  format: uuid
                  description: >-
                    Optional caller-supplied per-command correlation id, a bare lowercase RFC-4122 v4 UUID (no prefix).
                    Echoed back as `operation_uuid` in the 202 ack. A later lifecycle webhook carries it only when the
                    gateway can unambiguously associate that event with this command; the field is correlation, not
                    proof of causation. When omitted, the gateway mints one. Not an idempotency key — request
                    deduplication is the `Idempotency-Key` header. Invalid input (not a v4 UUID) is rejected with `400
                    invalid_request`.
                from_session_audio_rate:
                  type: integer
                  description: |-
                    Sample rate (Hz) of audio captured from the session and sent to the
                    backend. One of 8000, 16000, 24000, or any multiple of 8000 up to
                    192000.
                headers:
                  type: object
                  additionalProperties:
                    type: string
                  description: |-
                    Header name→value map sent on the WebSocket handshake (e.g. auth).
                    Bounded count and total size; values may not contain line breaks.
                start_muted:
                  type: boolean
                  default: false
                  description: If true, the user's audio is not sent to the backend until `ws/unmute`.
                to_session_audio_rate:
                  type: integer
                  description: >-
                    Sample rate (Hz) of audio the backend pushes back to the session. Same bounds as
                    `from_session_audio_rate`.
                url:
                  type: string
                  format: uri
                  description: |-
                    WebSocket relay URL. `wss://` is accepted by default. Controlled
                    deployments may opt into plaintext `ws://` by setting
                    `WS_RELAY_ALLOW_INSECURE=true`; without that explicit server-side
                    setting, `ws://` is rejected. The host must resolve to a permitted
                    public address; private, loopback, and link-local targets are
                    rejected (SSRF protection).
              required:
                - from_session_audio_rate
                - to_session_audio_rate
                - url
  /v1/sessions/{uuid}/websocket/stop:
    post:
      operationId: wsStop
      summary: Stop a WebSocket audio relay
      description: |-
        Stop the relay. On a standalone `ws` session this **ends the session**
        (equivalent to hangup) and emits a `session.ended` webhook. On a phone
        call only the relay stops and the call continues.

        **Triggered webhook:** `session.ended` for a standalone `ws` session.
        A deliberate stop does not emit `websocket.disconnected`; stopping a relay on
        a phone call emits no stop webhook.
      tags:
        - webSocket
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) UUID (format `{5-char-prefix}-{uuid}`).'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>`. See
            [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional client-generated key for a mutating endpoint. It identifies one method, route, query, content type,
            and exact raw body within the authenticated app. Reusing it for a different request returns 422. While its
            record exists, a retry replays the original accepted response when available. Keys are valid for 1 hour.
            Allowed characters: letters, digits, dot, hyphen, underscore; max 128 characters. See the Idempotency guide.
          required: false
          schema:
            type: string
      responses:
        '202':
          description: Command accepted for async execution
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AsyncCommandResponse'
        '400':
          description: >-
            Missing `Authorization`, malformed Bearer credentials, or invalid request parameters. A syntactically valid
            credential with an invalid API key returns `401` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsStopRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsStopRequestUnauthorizedError'
        '404':
          description: >-
            Session not found. A session owned by a *different* application returns this same `404` (never a `403`) so
            the response cannot be used to probe for the existence of another tenant's session.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsStopRequestNotFoundError'
        '409':
          description: >-
            The request cannot be completed because of state conflict — typically the session is terminating, or the
            resource (room, recording) is in a state incompatible with this command. On an operation that accepts
            `Idempotency-Key`, this status can also mean the original request with that key is still in progress; wait
            for its result rather than sending a different request with the same key.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsStopRequestConflictError'
        '413':
          description: Request body exceeds the endpoint's size limit.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsStopRequestContentTooLargeError'
        '415':
          description: 'A request with a JSON body must use `Content-Type: application/json`.'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsStopRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different request body. A key maps to one request; use a new key.
            See the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsStopRequestUnprocessableEntityError'
        '429':
          description: >-
            Rate limit exceeded — a per-command, per-room, or per-app token bucket was empty. The `retry_after` field
            gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsStopRequestTooManyRequestsError'
        '500':
          description: Internal gateway error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsStopRequestInternalServerError'
        '503':
          description: >-
            When an `Idempotency-Key` was supplied, the idempotency store is unavailable and the request was NOT
            processed; retry with the same key. Some operations can also return `503` for an unavailable room/session
            source or another documented dependency even when no key was supplied; in that case this response does not
            imply idempotency-store failure. See the operation description and the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsStopRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties:
                operation_uuid:
                  type: string
                  format: uuid
                  description: >-
                    Optional caller-supplied per-command correlation id, a bare lowercase RFC-4122 v4 UUID (no prefix).
                    Echoed back as `operation_uuid` in the 202 ack. A later lifecycle webhook carries it only when the
                    gateway can unambiguously associate that event with this command; the field is correlation, not
                    proof of causation. When omitted, the gateway mints one. Not an idempotency key — request
                    deduplication is the `Idempotency-Key` header. Invalid input (not a v4 UUID) is rejected with `400
                    invalid_request`.
                final_text:
                  type: string
                  description: Optional final text frame (≤ 4 KB) delivered to the backend before close.
  /v1/sessions/{uuid}/websocket/unmute:
    post:
      operationId: wsUnmute
      summary: Unmute a relay leg
      description: |-
        Unmute audio in one direction of the relay. Works on both a per-call
        relay and a standalone `ws` session.

        **Triggered webhooks:** `command.websocket.unmute.accepted`
      tags:
        - webSocket
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) UUID (format `{5-char-prefix}-{uuid}`).'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>`. See
            [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional client-generated key for a mutating endpoint. It identifies one method, route, query, content type,
            and exact raw body within the authenticated app. Reusing it for a different request returns 422. While its
            record exists, a retry replays the original accepted response when available. Keys are valid for 1 hour.
            Allowed characters: letters, digits, dot, hyphen, underscore; max 128 characters. See the Idempotency guide.
          required: false
          schema:
            type: string
      responses:
        '202':
          description: Command accepted for async execution
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AsyncCommandResponse'
        '400':
          description: >-
            Missing `Authorization`, malformed Bearer credentials, or invalid request parameters. A syntactically valid
            credential with an invalid API key returns `401` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsUnmuteRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsUnmuteRequestUnauthorizedError'
        '404':
          description: >-
            Session not found. A session owned by a *different* application returns this same `404` (never a `403`) so
            the response cannot be used to probe for the existence of another tenant's session.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsUnmuteRequestNotFoundError'
        '409':
          description: >-
            The request cannot be completed because of state conflict — typically the session is terminating, or the
            resource (room, recording) is in a state incompatible with this command. On an operation that accepts
            `Idempotency-Key`, this status can also mean the original request with that key is still in progress; wait
            for its result rather than sending a different request with the same key.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsUnmuteRequestConflictError'
        '413':
          description: Request body exceeds the endpoint's size limit.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsUnmuteRequestContentTooLargeError'
        '415':
          description: 'A request with a JSON body must use `Content-Type: application/json`.'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsUnmuteRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different request body. A key maps to one request; use a new key.
            See the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsUnmuteRequestUnprocessableEntityError'
        '429':
          description: >-
            Rate limit exceeded — a per-command, per-room, or per-app token bucket was empty. The `retry_after` field
            gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsUnmuteRequestTooManyRequestsError'
        '500':
          description: Internal gateway error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsUnmuteRequestInternalServerError'
        '503':
          description: >-
            When an `Idempotency-Key` was supplied, the idempotency store is unavailable and the request was NOT
            processed; retry with the same key. Some operations can also return `503` for an unavailable room/session
            source or another documented dependency even when no key was supplied; in that case this response does not
            imply idempotency-store failure. See the operation description and the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WsUnmuteRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties:
                operation_uuid:
                  type: string
                  format: uuid
                  description: >-
                    Optional caller-supplied per-command correlation id, a bare lowercase RFC-4122 v4 UUID (no prefix).
                    Echoed back as `operation_uuid` in the 202 ack. A later lifecycle webhook carries it only when the
                    gateway can unambiguously associate that event with this command; the field is correlation, not
                    proof of causation. When omitted, the gateway mints one. Not an idempotency key — request
                    deduplication is the `Idempotency-Key` header. Invalid input (not a v4 UUID) is rejected with `400
                    invalid_request`.
                leg:
                  $ref: '#/components/schemas/V1SessionsUuidWebsocketUnmutePostRequestBodyContentApplicationJsonSchemaLeg'
                  description: |-
                    Which direction the mute/unmute applies to: `user` (audio from the
                    caller), `backend` (audio from the backend), or `all`.
              required:
                - leg
  /v1/sessions/{uuid}/playback/pause:
    post:
      operationId: pausePlayback
      summary: Pause playback
      description: |-
        **Rate limit: Per command** · **Burst:** 20 · **Refill:** 20 req/s

        Pause active playback.

        **Triggered webhooks:** `command.playback.pause.accepted` (immediate)
      tags:
        - playback
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) UUID (format `{5-char-prefix}-{uuid}`).'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>`. See
            [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional client-generated key for a mutating endpoint. It identifies one method, route, query, content type,
            and exact raw body within the authenticated app. Reusing it for a different request returns 422. While its
            record exists, a retry replays the original accepted response when available. Keys are valid for 1 hour.
            Allowed characters: letters, digits, dot, hyphen, underscore; max 128 characters. See the Idempotency guide.
          required: false
          schema:
            type: string
      responses:
        '202':
          description: Command accepted for async execution
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AsyncCommandResponse'
        '400':
          description: >-
            Missing `Authorization`, malformed Bearer credentials, or invalid request parameters. A syntactically valid
            credential with an invalid API key returns `401` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PausePlaybackRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PausePlaybackRequestUnauthorizedError'
        '404':
          description: The requested resource was not found or is not owned by the authenticated app.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PausePlaybackRequestNotFoundError'
        '409':
          description: >-
            The request cannot be completed because of state conflict — typically the session is terminating, or the
            resource (room, recording) is in a state incompatible with this command. On an operation that accepts
            `Idempotency-Key`, this status can also mean the original request with that key is still in progress; wait
            for its result rather than sending a different request with the same key.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PausePlaybackRequestConflictError'
        '413':
          description: Request body exceeds the endpoint's size limit.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PausePlaybackRequestContentTooLargeError'
        '415':
          description: 'A request with a JSON body must use `Content-Type: application/json`.'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PausePlaybackRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different request body. A key maps to one request; use a new key.
            See the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PausePlaybackRequestUnprocessableEntityError'
        '429':
          description: >-
            Rate limit exceeded — a per-command, per-room, or per-app token bucket was empty. The `retry_after` field
            gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PausePlaybackRequestTooManyRequestsError'
        '500':
          description: Internal gateway error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PausePlaybackRequestInternalServerError'
        '503':
          description: >-
            When an `Idempotency-Key` was supplied, the idempotency store is unavailable and the request was NOT
            processed; retry with the same key. Some operations can also return `503` for an unavailable room/session
            source or another documented dependency even when no key was supplied; in that case this response does not
            imply idempotency-store failure. See the operation description and the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PausePlaybackRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/CommandRequest'
  /v1/sessions/{uuid}/playback/play:
    post:
      operationId: startAudioPlayback
      summary: Start audio playback
      description: |-
        **Rate limit: Per command** · **Burst:** 8 · **Refill:** 4 req/s

        Start finite-file, live-stream, or silence playback. Stops any active playback first (last-wins semantics).

        Before accepting a finite URL playback, the gateway probes each source
        with HEAD first and falls back to a ranged GET. A source that cannot be
        prepared returns a synchronous HTTP error, and no playback webhook is emitted. After a
        request is accepted, a later start failure emits `playback.failed`.

        **Triggered webhooks:** `playback.started`, `playback.stopped`,
        `playback.failed` (on error)

        **Note on `playback.started` timing.** `playback.started` fires at the
        true sound-start — the moment audio actually begins playing on the call,
        not when the request is accepted. The gateway stages the event at
        dispatch and emits it only when playback actually begins (audible),
        so `timestamp` reflects real audio start (usable to measure
        start latency). If playback never starts, `playback.failed` fires instead.
      tags:
        - playback
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) UUID (format `{5-char-prefix}-{uuid}`).'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>`. See
            [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional client-generated key for a mutating endpoint. It identifies one method, route, query, content type,
            and exact raw body within the authenticated app. Reusing it for a different request returns 422. While its
            record exists, a retry replays the original accepted response when available. Keys are valid for 1 hour.
            Allowed characters: letters, digits, dot, hyphen, underscore; max 128 characters. See the Idempotency guide.
          required: false
          schema:
            type: string
      responses:
        '202':
          description: Command accepted for async execution
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AsyncCommandResponse'
        '400':
          description: >-
            Missing `Authorization`, malformed Bearer credentials, or invalid request parameters. A syntactically valid
            credential with an invalid API key returns `401` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StartAudioPlaybackRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StartAudioPlaybackRequestUnauthorizedError'
        '404':
          description: >-
            Session not found. A session owned by a *different* application returns this same `404` (never a `403`) so
            the response cannot be used to probe for the existence of another tenant's session.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StartAudioPlaybackRequestNotFoundError'
        '409':
          description: A media transition is already in progress; retry after it settles.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StartAudioPlaybackRequestConflictError'
        '413':
          description: Request body exceeds the endpoint's size limit.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StartAudioPlaybackRequestContentTooLargeError'
        '415':
          description: 'A request with a JSON body must use `Content-Type: application/json`.'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StartAudioPlaybackRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different request body. A key maps to one request; use a new key.
            See the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StartAudioPlaybackRequestUnprocessableEntityError'
        '429':
          description: >-
            Rate limit exceeded — a per-command, per-room, or per-app token bucket was empty. The `retry_after` field
            gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StartAudioPlaybackRequestTooManyRequestsError'
        '500':
          description: Internal gateway error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StartAudioPlaybackRequestInternalServerError'
        '502':
          description: The playback source is unavailable, so the command was not accepted.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StartAudioPlaybackRequestBadGatewayError'
        '503':
          description: Playback stop unavailable while replacing active playback.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StartAudioPlaybackRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/Playback_startAudioPlayback_Request'
  /v1/sessions/{uuid}/playback/restart:
    post:
      operationId: restartPlayback
      summary: Restart playback
      description: |-
        **Rate limit: Per command** · **Burst:** 20 · **Refill:** 20 req/s

        Restart playback from the beginning.

        **Triggered webhooks:** `command.playback.restart.accepted` (immediate).
        If no playback is active the command is rejected and `playback.failed`
        `{reason:"no_active_playback"}` fires instead.
      tags:
        - playback
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) UUID (format `{5-char-prefix}-{uuid}`).'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>`. See
            [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional client-generated key for a mutating endpoint. It identifies one method, route, query, content type,
            and exact raw body within the authenticated app. Reusing it for a different request returns 422. While its
            record exists, a retry replays the original accepted response when available. Keys are valid for 1 hour.
            Allowed characters: letters, digits, dot, hyphen, underscore; max 128 characters. See the Idempotency guide.
          required: false
          schema:
            type: string
      responses:
        '202':
          description: Command accepted for async execution
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AsyncCommandResponse'
        '400':
          description: >-
            Missing `Authorization`, malformed Bearer credentials, or invalid request parameters. A syntactically valid
            credential with an invalid API key returns `401` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RestartPlaybackRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RestartPlaybackRequestUnauthorizedError'
        '404':
          description: The requested resource was not found or is not owned by the authenticated app.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RestartPlaybackRequestNotFoundError'
        '409':
          description: >-
            The request cannot be completed because of state conflict — typically the session is terminating, or the
            resource (room, recording) is in a state incompatible with this command. On an operation that accepts
            `Idempotency-Key`, this status can also mean the original request with that key is still in progress; wait
            for its result rather than sending a different request with the same key.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RestartPlaybackRequestConflictError'
        '413':
          description: Request body exceeds the endpoint's size limit.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RestartPlaybackRequestContentTooLargeError'
        '415':
          description: 'A request with a JSON body must use `Content-Type: application/json`.'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RestartPlaybackRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different request body. A key maps to one request; use a new key.
            See the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RestartPlaybackRequestUnprocessableEntityError'
        '429':
          description: >-
            Rate limit exceeded — a per-command, per-room, or per-app token bucket was empty. The `retry_after` field
            gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RestartPlaybackRequestTooManyRequestsError'
        '500':
          description: Internal gateway error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RestartPlaybackRequestInternalServerError'
        '503':
          description: >-
            When an `Idempotency-Key` was supplied, the idempotency store is unavailable and the request was NOT
            processed; retry with the same key. Some operations can also return `503` for an unavailable room/session
            source or another documented dependency even when no key was supplied; in that case this response does not
            imply idempotency-store failure. See the operation description and the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RestartPlaybackRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/CommandRequest'
  /v1/sessions/{uuid}/playback/resume:
    post:
      operationId: resumePlayback
      summary: Resume playback
      description: |-
        **Rate limit: Per command** · **Burst:** 20 · **Refill:** 20 req/s

        Resume paused playback.

        **Triggered webhooks:** `command.playback.resume.accepted` (immediate)
      tags:
        - playback
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) UUID (format `{5-char-prefix}-{uuid}`).'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>`. See
            [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional client-generated key for a mutating endpoint. It identifies one method, route, query, content type,
            and exact raw body within the authenticated app. Reusing it for a different request returns 422. While its
            record exists, a retry replays the original accepted response when available. Keys are valid for 1 hour.
            Allowed characters: letters, digits, dot, hyphen, underscore; max 128 characters. See the Idempotency guide.
          required: false
          schema:
            type: string
      responses:
        '202':
          description: Command accepted for async execution
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AsyncCommandResponse'
        '400':
          description: >-
            Missing `Authorization`, malformed Bearer credentials, or invalid request parameters. A syntactically valid
            credential with an invalid API key returns `401` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ResumePlaybackRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ResumePlaybackRequestUnauthorizedError'
        '404':
          description: The requested resource was not found or is not owned by the authenticated app.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ResumePlaybackRequestNotFoundError'
        '409':
          description: >-
            The request cannot be completed because of state conflict — typically the session is terminating, or the
            resource (room, recording) is in a state incompatible with this command. On an operation that accepts
            `Idempotency-Key`, this status can also mean the original request with that key is still in progress; wait
            for its result rather than sending a different request with the same key.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ResumePlaybackRequestConflictError'
        '413':
          description: Request body exceeds the endpoint's size limit.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ResumePlaybackRequestContentTooLargeError'
        '415':
          description: 'A request with a JSON body must use `Content-Type: application/json`.'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ResumePlaybackRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different request body. A key maps to one request; use a new key.
            See the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ResumePlaybackRequestUnprocessableEntityError'
        '429':
          description: >-
            Rate limit exceeded — a per-command, per-room, or per-app token bucket was empty. The `retry_after` field
            gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ResumePlaybackRequestTooManyRequestsError'
        '500':
          description: Internal gateway error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ResumePlaybackRequestInternalServerError'
        '503':
          description: >-
            When an `Idempotency-Key` was supplied, the idempotency store is unavailable and the request was NOT
            processed; retry with the same key. Some operations can also return `503` for an unavailable room/session
            source or another documented dependency even when no key was supplied; in that case this response does not
            imply idempotency-store failure. See the operation description and the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ResumePlaybackRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/CommandRequest'
  /v1/sessions/{uuid}/playback/seek:
    post:
      operationId: seekWithinPlayback
      summary: Seek within playback
      description: |-
        **Rate limit: Per command** · **Burst:** 20 · **Refill:** 20 req/s

        Seek within active playback.

        **Triggered webhooks:** `command.playback.seek.accepted` (immediate, carries `offset_ms`)
      tags:
        - playback
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) UUID (format `{5-char-prefix}-{uuid}`).'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>`. See
            [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional client-generated key for a mutating endpoint. It identifies one method, route, query, content type,
            and exact raw body within the authenticated app. Reusing it for a different request returns 422. While its
            record exists, a retry replays the original accepted response when available. Keys are valid for 1 hour.
            Allowed characters: letters, digits, dot, hyphen, underscore; max 128 characters. See the Idempotency guide.
          required: false
          schema:
            type: string
      responses:
        '202':
          description: Command accepted for async execution
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AsyncCommandResponse'
        '400':
          description: >-
            Missing `Authorization`, malformed Bearer credentials, or invalid request parameters. A syntactically valid
            credential with an invalid API key returns `401` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SeekWithinPlaybackRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SeekWithinPlaybackRequestUnauthorizedError'
        '404':
          description: The requested resource was not found or is not owned by the authenticated app.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SeekWithinPlaybackRequestNotFoundError'
        '409':
          description: >-
            The request cannot be completed because of state conflict — typically the session is terminating, or the
            resource (room, recording) is in a state incompatible with this command. On an operation that accepts
            `Idempotency-Key`, this status can also mean the original request with that key is still in progress; wait
            for its result rather than sending a different request with the same key.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SeekWithinPlaybackRequestConflictError'
        '413':
          description: Request body exceeds the endpoint's size limit.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SeekWithinPlaybackRequestContentTooLargeError'
        '415':
          description: 'A request with a JSON body must use `Content-Type: application/json`.'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SeekWithinPlaybackRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different request body. A key maps to one request; use a new key.
            See the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SeekWithinPlaybackRequestUnprocessableEntityError'
        '429':
          description: >-
            Rate limit exceeded — a per-command, per-room, or per-app token bucket was empty. The `retry_after` field
            gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SeekWithinPlaybackRequestTooManyRequestsError'
        '500':
          description: Internal gateway error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SeekWithinPlaybackRequestInternalServerError'
        '503':
          description: >-
            When an `Idempotency-Key` was supplied, the idempotency store is unavailable and the request was NOT
            processed; retry with the same key. Some operations can also return `503` for an unavailable room/session
            source or another documented dependency even when no key was supplied; in that case this response does not
            imply idempotency-store failure. See the operation description and the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SeekWithinPlaybackRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties:
                operation_uuid:
                  type: string
                  format: uuid
                  description: >-
                    Optional caller-supplied per-command correlation id, a bare lowercase RFC-4122 v4 UUID (no prefix).
                    Echoed back as `operation_uuid` in the 202 ack. A later lifecycle webhook carries it only when the
                    gateway can unambiguously associate that event with this command; the field is correlation, not
                    proof of causation. When omitted, the gateway mints one. Not an idempotency key — request
                    deduplication is the `Idempotency-Key` header. Invalid input (not a v4 UUID) is rejected with `400
                    invalid_request`.
                seek_ms:
                  type: integer
                  description: |-
                    Seek offset in milliseconds. Positive seeks forward; negative rewinds.
                    Must be non-zero (zero causes unintended 1000ms forward jump).
              required:
                - seek_ms
  /v1/sessions/{uuid}/playback/stop:
    post:
      operationId: stopPlayback
      summary: Stop playback
      description: |-
        **Rate limit: Per command** · **Burst:** 20 · **Refill:** 20 req/s

        Stop active playback immediately.

        **Triggered webhooks:** `playback.stopped` (deferred, from interrupted playback)
      tags:
        - playback
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) UUID (format `{5-char-prefix}-{uuid}`).'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>`. See
            [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional client-generated key for a mutating endpoint. It identifies one method, route, query, content type,
            and exact raw body within the authenticated app. Reusing it for a different request returns 422. While its
            record exists, a retry replays the original accepted response when available. Keys are valid for 1 hour.
            Allowed characters: letters, digits, dot, hyphen, underscore; max 128 characters. See the Idempotency guide.
          required: false
          schema:
            type: string
      responses:
        '202':
          description: Command accepted for async execution
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AsyncCommandResponse'
        '400':
          description: >-
            Missing `Authorization`, malformed Bearer credentials, or invalid request parameters. A syntactically valid
            credential with an invalid API key returns `401` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StopPlaybackRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StopPlaybackRequestUnauthorizedError'
        '404':
          description: The requested resource was not found or is not owned by the authenticated app.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StopPlaybackRequestNotFoundError'
        '409':
          description: A media transition is already in progress; retry after it settles.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StopPlaybackRequestConflictError'
        '413':
          description: Request body exceeds the endpoint's size limit.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StopPlaybackRequestContentTooLargeError'
        '415':
          description: 'A request with a JSON body must use `Content-Type: application/json`.'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StopPlaybackRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different request body. A key maps to one request; use a new key.
            See the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StopPlaybackRequestUnprocessableEntityError'
        '429':
          description: >-
            Rate limit exceeded — a per-command, per-room, or per-app token bucket was empty. The `retry_after` field
            gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StopPlaybackRequestTooManyRequestsError'
        '500':
          description: Internal gateway error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StopPlaybackRequestInternalServerError'
        '503':
          description: Playback stop unavailable; no stop was dispatched.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StopPlaybackRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/CommandRequest'
  /v1/sessions/{uuid}/play_and_get_digits:
    post:
      operationId: playPromptAndCollectDTMFDigits
      summary: Play prompt and collect DTMF digits
      description: |-
        **Rate limit: Per command** · **Burst:** 4 · **Refill:** 0.8 req/s

        This POST has its own bucket. The cancel DELETE is configured identically, but uses a separate bucket.

        Play an audio prompt and collect DTMF digits from the caller.

        **Single-shot:** the gateway runs exactly one prompt/collect cycle and
        emits one `digits.collected` carrying a `status`. The gateway never
        retries on its own — **the client owns the retry loop**: inspect the
        `status` field and re-issue this command with whatever prompt fits
        (e.g. an "invalid PIN" prompt on `status: invalid`).

        **Triggered webhooks:** `digits.collected`. Individual `dtmf.received`
        events also fire during collection. For every finite prompt source, the
        gateway probes with HEAD first and falls back to a ranged GET. A prompt
        that cannot be prepared returns a synchronous HTTP error and emits no webhook.
      tags:
        - collectKeypadInput
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) UUID (format `{5-char-prefix}-{uuid}`).'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>`. See
            [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional client-generated key for a mutating endpoint. It identifies one method, route, query, content type,
            and exact raw body within the authenticated app. Reusing it for a different request returns 422. While its
            record exists, a retry replays the original accepted response when available. Keys are valid for 1 hour.
            Allowed characters: letters, digits, dot, hyphen, underscore; max 128 characters. See the Idempotency guide.
          required: false
          schema:
            type: string
      responses:
        '202':
          description: Command accepted for async execution
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AsyncCommandResponse'
        '400':
          description: >-
            Missing `Authorization`, malformed Bearer credentials, or invalid request parameters. A syntactically valid
            credential with an invalid API key returns `401` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PlayPromptAndCollectDTMFDigitsRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PlayPromptAndCollectDTMFDigitsRequestUnauthorizedError'
        '404':
          description: The requested resource was not found or is not owned by the authenticated app.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PlayPromptAndCollectDTMFDigitsRequestNotFoundError'
        '409':
          description: A media transition is already in progress; retry after it settles.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PlayPromptAndCollectDTMFDigitsRequestConflictError'
        '413':
          description: Request body exceeds the endpoint's size limit.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PlayPromptAndCollectDTMFDigitsRequestContentTooLargeError'
        '415':
          description: 'A request with a JSON body must use `Content-Type: application/json`.'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PlayPromptAndCollectDTMFDigitsRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different request body. A key maps to one request; use a new key.
            See the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PlayPromptAndCollectDTMFDigitsRequestUnprocessableEntityError'
        '429':
          description: >-
            Rate limit exceeded — a per-command, per-room, or per-app token bucket was empty. The `retry_after` field
            gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PlayPromptAndCollectDTMFDigitsRequestTooManyRequestsError'
        '500':
          description: Internal gateway error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PlayPromptAndCollectDTMFDigitsRequestInternalServerError'
        '502':
          description: The prompt source is unavailable, so the command was not accepted.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PlayPromptAndCollectDTMFDigitsRequestBadGatewayError'
        '503':
          description: Playback stop unavailable while replacing the active prompt or playback.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PlayPromptAndCollectDTMFDigitsRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties:
                operation_uuid:
                  type: string
                  format: uuid
                  description: >-
                    Optional caller-supplied per-command correlation id, a bare lowercase RFC-4122 v4 UUID (no prefix).
                    Echoed back as `operation_uuid` in the 202 ack. A later lifecycle webhook carries it only when the
                    gateway can unambiguously associate that event with this command; the field is correlation, not
                    proof of causation. When omitted, the gateway mints one. Not an idempotency key — request
                    deduplication is the `Idempotency-Key` header. Invalid input (not a v4 UUID) is rejected with `400
                    invalid_request`.
                between_digits_timeout_ms:
                  type: integer
                  default: 2000
                  description: Milliseconds to wait between digits before timing out.
                first_digit_timeout_ms:
                  type: integer
                  default: 5000
                  description: Milliseconds to wait for the first digit before timing out.
                max_digits:
                  type: integer
                  default: 10
                  description: Maximum digits to collect. Must be >= min_digits.
                min_digits:
                  type: integer
                  default: 1
                prompt_files:
                  type: array
                  items:
                    type: string
                    format: uri
                  description: Audio URLs to play as the prompt (http(s) only).
                terminators:
                  type: array
                  items:
                    $ref: >-
                      #/components/schemas/V1SessionsUuidPlayAndGetDigitsPostRequestBodyContentApplicationJsonSchemaTerminatorsItems
                  default:
                    - '#'
                  description: 'DTMF terminator characters. Only # and * allowed.'
                validation:
                  $ref: >-
                    #/components/schemas/V1SessionsUuidPlayAndGetDigitsPostRequestBodyContentApplicationJsonSchemaValidation
                  description: Optional input validation.
              required:
                - prompt_files
    delete:
      operationId: cancelPlayPromptAndCollectDTMFDigits
      summary: Cancel an in-progress play_and_get_digits
      description: |-
        **Rate limit: Per command** · **Burst:** 4 · **Refill:** 0.8 req/s

        This DELETE has its own bucket. The POST is configured identically, but uses a separate bucket.

        Cancel an in-progress `play_and_get_digits` on this session. Interrupts
        the prompt/collect cycle; the resulting `digits.collected` carries
        `status: cancelled`. Applies to the most recently dispatched
        `play_and_get_digits`; with none in progress the request is accepted
        and has no effect.

        Residual latency: cancellation stops prompt audio
        promptly, but the cancelled command's terminal `digits.collected`
        (`status: cancelled`) does not fire until the in-progress collect phase
        ends on the media layer's own timers — it is not delivered the instant you call
        DELETE. Input entered after a cancel is discarded — reported on the
        cancelled command's `digits.collected` event, never delivered to a later
        command.
      tags:
        - collectKeypadInput
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) UUID (format `{5-char-prefix}-{uuid}`).'
          required: true
          schema:
            type: string
        - name: operation_uuid
          in: query
          description: |-
            Client-supplied UUID to label this cancel operation; must be a valid
            UUID or the request is rejected with 400; a UUID is generated when
            omitted. Echoed back as `operation_uuid` in the 202 response and on
            the resulting webhook.
          required: false
          schema:
            type: string
            format: uuid
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>`. See
            [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for details.
          required: true
          schema:
            type: string
      responses:
        '202':
          description: Cancellation accepted.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Collect keypad input_cancelPlayPromptAndCollectDTMFDigits_Response_202'
        '400':
          description: >-
            Missing `Authorization`, malformed Bearer credentials, or invalid request parameters. A syntactically valid
            credential with an invalid API key returns `401` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CancelPlayPromptAndCollectDTMFDigitsRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CancelPlayPromptAndCollectDTMFDigitsRequestUnauthorizedError'
        '404':
          description: The requested resource was not found or is not owned by the authenticated app.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CancelPlayPromptAndCollectDTMFDigitsRequestNotFoundError'
        '429':
          description: >-
            Rate limit exceeded — a per-command, per-room, or per-app token bucket was empty. The `retry_after` field
            gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CancelPlayPromptAndCollectDTMFDigitsRequestTooManyRequestsError'
        '500':
          description: Internal gateway error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CancelPlayPromptAndCollectDTMFDigitsRequestInternalServerError'
  /api/v1/app/webhook:
    get:
      operationId: getWebhookConfiguration
      summary: Get webhook delivery URL
      description: >-
        Temporary endpoint. A complete interface for managing applications, phone numbers, tokens, and other settings
        will replace it soon. Returns the webhook URL for the authenticated application only.
      tags:
        - webhooks
      parameters:
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>`. See
            [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for details.
          required: true
          schema:
            type: string
      responses:
        '200':
          description: Current webhook configuration
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AppWebhookConfigResponse'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/GetWebhookConfigurationRequestUnauthorizedError'
        '500':
          description: Internal gateway error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/GetWebhookConfigurationRequestInternalServerError'
        '503':
          description: The configuration store is temporarily unavailable; retry the request.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/GetWebhookConfigurationRequestServiceUnavailableError'
    put:
      operationId: updateWebhookConfiguration
      summary: Update webhook delivery URL
      description: >-
        Temporary endpoint. A complete interface for managing applications, phone numbers, tokens, and other settings
        will replace it soon. Updates the webhook URL for the authenticated application only. Set `webhook_url` to null
        or an empty string to disable delivery. The new setting applies to webhook deliveries created after this request
        succeeds.
      tags:
        - webhooks
      parameters:
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>`. See
            [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for details.
          required: true
          schema:
            type: string
      responses:
        '200':
          description: Webhook configuration saved
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AppWebhookConfigResponse'
        '400':
          description: >-
            Missing `Authorization`, malformed Bearer credentials, or invalid request parameters. A syntactically valid
            credential with an invalid API key returns `401` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UpdateWebhookConfigurationRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UpdateWebhookConfigurationRequestUnauthorizedError'
        '413':
          description: Request body exceeds the endpoint's size limit.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UpdateWebhookConfigurationRequestContentTooLargeError'
        '415':
          description: 'A request with a JSON body must use `Content-Type: application/json`.'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UpdateWebhookConfigurationRequestUnsupportedMediaTypeError'
        '500':
          description: Internal gateway error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UpdateWebhookConfigurationRequestInternalServerError'
        '503':
          description: The configuration store is temporarily unavailable; retry the request.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UpdateWebhookConfigurationRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/AppWebhookConfigRequest'
  /health:
    get:
      operationId: check
      summary: Health check
      description: Public health check endpoint. No authentication required.
      tags:
        - health
      responses:
        '200':
          description: Service is healthy
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Health_check_Response_200'
        '503':
          description: A required dependency is unavailable; the service is not ready to receive traffic.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HealthCheckRequestServiceUnavailableError'
  /livez:
    get:
      operationId: livenessCheck
      summary: Liveness probe
      description: |-
        Process **liveness** probe. Unauthenticated, always returns `200`,
        and deliberately touches no external dependency or session state. It
        answers a single question: "is this API process alive and serving
        HTTP?"

        Use `/health` (readiness), not this endpoint, to gauge whether the
        service can actually handle traffic — `/livez` continues to return
        `200` through a transient dependency outage so a healthy process is
        not killed.
      tags:
        - health
      responses:
        '200':
          description: Process is alive
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Health_livenessCheck_Response_200'
servers:
  - url: https://api.telekesher.dev
    description: Gateway server
components:
  schemas:
    V1SessionsDialPostResponsesContentApplicationJsonSchemaStatus:
      type: string
      enum:
        - dialing
      title: V1SessionsDialPostResponsesContentApplicationJsonSchemaStatus
    Call Control_createDial_Response_202:
      type: object
      properties:
        session_uuid:
          type: string
        status:
          $ref: '#/components/schemas/V1SessionsDialPostResponsesContentApplicationJsonSchemaStatus'
      required:
        - session_uuid
        - status
      title: Call Control_createDial_Response_202
    V1SessionsDialPostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
        - internal
      description: >-
        Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
        handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
        `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
        `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
        `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


        Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
        size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
        query with filters and retry).


        Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
        conditions: `502` means a command dependency could not accept the request, `503` means a required service
        (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no
        spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
      title: V1SessionsDialPostResponsesContentApplicationJsonSchemaCode
    CreateDialRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsDialPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: CreateDialRequestBadRequestError
    CreateDialRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsDialPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: CreateDialRequestUnauthorizedError
    CreateDialRequestForbiddenError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsDialPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: CreateDialRequestForbiddenError
    CreateDialRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsDialPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: CreateDialRequestConflictError
    CreateDialRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsDialPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: CreateDialRequestContentTooLargeError
    CreateDialRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsDialPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: CreateDialRequestUnsupportedMediaTypeError
    CreateDialRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsDialPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: CreateDialRequestUnprocessableEntityError
    CreateDialRequestInternalServerError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsDialPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: CreateDialRequestInternalServerError
    CreateDialRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsDialPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: CreateDialRequestServiceUnavailableError
    V1SessionsConnectWebsocketPostRequestBodyContentApplicationJsonSchemaType:
      type: string
      enum:
        - websocket
      description: Session type to create. Only `websocket` is supported.
      title: V1SessionsConnectWebsocketPostRequestBodyContentApplicationJsonSchemaType
    WebSocketRelayConfig:
      type: object
      properties:
        from_session_audio_rate:
          type: integer
          description: |-
            Sample rate (Hz) of audio captured from the session and sent to the
            backend. One of 8000, 16000, 24000, or any multiple of 8000 up to
            192000.
        headers:
          type: object
          additionalProperties:
            type: string
          description: |-
            Header name→value map sent on the WebSocket handshake (e.g. auth).
            Bounded count and total size; values may not contain line breaks.
        start_muted:
          type: boolean
          default: false
          description: If true, the user's audio is not sent to the backend until `ws/unmute`.
        to_session_audio_rate:
          type: integer
          description: Sample rate (Hz) of audio the backend pushes back to the session. Same bounds as `from_session_audio_rate`.
        url:
          type: string
          format: uri
          description: |-
            WebSocket relay URL. `wss://` is accepted by default. Controlled
            deployments may opt into plaintext `ws://` by setting
            `WS_RELAY_ALLOW_INSECURE=true`; without that explicit server-side
            setting, `ws://` is rejected. The host must resolve to a permitted
            public address; private, loopback, and link-local targets are
            rejected (SSRF protection).
      required:
        - from_session_audio_rate
        - to_session_audio_rate
        - url
      description: |-
        WebSocket audio relay configuration. Shared by the `ws/start` command and
        the `ws` block of `POST /v1/sessions`.
      title: WebSocketRelayConfig
    SessionState:
      type: string
      enum:
        - new
        - connecting
        - ringing
        - early_media
        - answered
        - ended
      description: |-
        Current lifecycle state of the session. `connecting` applies to a
        `websocket` session whose backend WebSocket has not yet connected.
      title: SessionState
    SessionType:
      type: string
      enum:
        - phone_in
        - phone_out
        - sip
        - webrtc
        - websocket
        - unknown
      description: |-
        The nature of the session:
        - `phone_in`: inbound phone call from a carrier
        - `phone_out`: outbound phone call placed with `dial`
        - `sip`: a registered SIP device
        - `webrtc`: a WebRTC client
        - `websocket`: a standalone WebSocket session with no phone leg
        - `unknown`: could not be determined
      title: SessionType
    Session:
      type: object
      properties:
        caller_id:
          type: string
          description: |-
            Caller ID in canonical international E.164 format with leading `+`
            (e.g. `+972527121102`). Empty for `websocket` sessions (no phone leg).
        created_at:
          type: string
          format: date-time
          description: |-
            When the session was created, as an RFC 3339 / ISO 8601 UTC string
            (e.g. "2025-05-06T12:41:36.000Z"). Storage resolution is one second,
            so the millisecond fraction is always `.000`. Empty string if the
            originating timestamp is missing or unparseable.
        did:
          type: string
          description: |-
            Called DID in canonical E.164 format with leading `+` (e.g. `+972747713001`).
            Empty for `websocket` sessions (no phone leg).
        session_uuid:
          type: string
          description: Opaque session identifier. Return it to the API exactly as received.
        state:
          $ref: '#/components/schemas/SessionState'
          description: |-
            Current lifecycle state of the session. `connecting` applies to a
            `websocket` session whose backend WebSocket has not yet connected.
        type:
          $ref: '#/components/schemas/SessionType'
          description: |-
            The nature of the session:
            - `phone_in`: inbound phone call from a carrier
            - `phone_out`: outbound phone call placed with `dial`
            - `sip`: a registered SIP device
            - `webrtc`: a WebRTC client
            - `websocket`: a standalone WebSocket session with no phone leg
            - `unknown`: could not be determined
      required:
        - created_at
        - session_uuid
        - state
        - type
      description: |-
        The opaque, 6-field view of a session. Identical shape on
        `GET /v1/sessions/{uuid}` and each item of `GET /v1/sessions`.
      title: Session
    V1SessionsConnectWebsocketPostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
        - internal
      description: >-
        Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
        handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
        `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
        `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
        `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


        Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
        size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
        query with filters and retry).


        Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
        conditions: `502` means a command dependency could not accept the request, `503` means a required service
        (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no
        spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
      title: V1SessionsConnectWebsocketPostResponsesContentApplicationJsonSchemaCode
    CreateSessionRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsConnectWebsocketPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: CreateSessionRequestBadRequestError
    CreateSessionRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsConnectWebsocketPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: CreateSessionRequestUnauthorizedError
    CreateSessionRequestForbiddenError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsConnectWebsocketPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: CreateSessionRequestForbiddenError
    CreateSessionRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsConnectWebsocketPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: CreateSessionRequestConflictError
    CreateSessionRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsConnectWebsocketPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: CreateSessionRequestContentTooLargeError
    CreateSessionRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsConnectWebsocketPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: CreateSessionRequestUnsupportedMediaTypeError
    CreateSessionRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsConnectWebsocketPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: CreateSessionRequestUnprocessableEntityError
    CreateSessionRequestInternalServerError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsConnectWebsocketPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: CreateSessionRequestInternalServerError
    CreateSessionRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsConnectWebsocketPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: CreateSessionRequestServiceUnavailableError
    V1SessionsGetParametersState:
      type: string
      enum:
        - new
        - connecting
        - ringing
        - early_media
        - answered
        - ended
      title: V1SessionsGetParametersState
    SessionListResponse:
      type: object
      properties:
        has_more:
          type: boolean
          description: True when more sessions matched than were returned.
        sessions:
          type: array
          items:
            $ref: '#/components/schemas/Session'
      required:
        - has_more
        - sessions
      title: SessionListResponse
    V1SessionsGetResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
        - internal
      description: >-
        Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
        handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
        `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
        `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
        `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


        Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
        size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
        query with filters and retry).


        Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
        conditions: `502` means a command dependency could not accept the request, `503` means a required service
        (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no
        spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
      title: V1SessionsGetResponsesContentApplicationJsonSchemaCode
    ListSessionsRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: ListSessionsRequestBadRequestError
    ListSessionsRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: ListSessionsRequestUnauthorizedError
    ListSessionsRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: ListSessionsRequestContentTooLargeError
    ListSessionsRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - retry_after
        - success
      title: ListSessionsRequestTooManyRequestsError
    ListSessionsRequestInternalServerError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: ListSessionsRequestInternalServerError
    SessionDetailsStatus:
      type: string
      enum:
        - new
        - connecting
        - ringing
        - early_media
        - answered
        - ended
      description: |-
        Current lifecycle status of the session. `connecting` applies to a
        `websocket` session whose backend WebSocket has not yet connected.
      title: SessionDetailsStatus
    SessionDetailsType:
      type: string
      enum:
        - phone_in
        - phone_out
        - sip
        - webrtc
        - websocket
        - unknown
      description: |-
        The nature of the session:
        - `phone_in`: inbound phone call from a carrier
        - `phone_out`: outbound phone call placed with `dial`
        - `sip`: a registered SIP device
        - `webrtc`: a WebRTC client
        - `websocket`: a standalone WebSocket session with no phone leg
        - `unknown`: could not be determined
      title: SessionDetailsType
    SessionDetails:
      type: object
      properties:
        caller_id:
          type: string
          description: |-
            Caller ID in canonical international E.164 format with leading `+`
            (e.g. `+972527121102`). Empty for `websocket` sessions (no phone leg).
        created_at:
          type: string
          format: date-time
          description: |-
            When the session was created, as an RFC 3339 / ISO 8601 UTC string
            (e.g. "2025-05-06T12:41:36.000Z"). Storage resolution is one second,
            so the millisecond fraction is always `.000`. Empty string if the
            originating timestamp is missing or unparseable.
        did:
          type: string
          description: |-
            Called DID in canonical E.164 format with leading `+` (e.g. `+972747713001`).
            Empty for `websocket` sessions (no phone leg).
        session_uuid:
          type: string
          description: Opaque session identifier. Return it to the API exactly as received.
        status:
          $ref: '#/components/schemas/SessionDetailsStatus'
          description: |-
            Current lifecycle status of the session. `connecting` applies to a
            `websocket` session whose backend WebSocket has not yet connected.
        type:
          $ref: '#/components/schemas/SessionDetailsType'
          description: |-
            The nature of the session:
            - `phone_in`: inbound phone call from a carrier
            - `phone_out`: outbound phone call placed with `dial`
            - `sip`: a registered SIP device
            - `webrtc`: a WebRTC client
            - `websocket`: a standalone WebSocket session with no phone leg
            - `unknown`: could not be determined
      required:
        - caller_id
        - created_at
        - did
        - session_uuid
        - status
        - type
      description: The opaque, 6-field view returned by `GET /v1/sessions/{uuid}`.
      title: SessionDetails
    V1SessionsUuidGetResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
        - internal
      description: >-
        Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
        handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
        `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
        `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
        `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


        Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
        size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
        query with filters and retry).


        Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
        conditions: `502` means a command dependency could not accept the request, `503` means a required service
        (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no
        spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
      title: V1SessionsUuidGetResponsesContentApplicationJsonSchemaCode
    GetSessionDetailsRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: GetSessionDetailsRequestBadRequestError
    GetSessionDetailsRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: GetSessionDetailsRequestUnauthorizedError
    GetSessionDetailsRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: GetSessionDetailsRequestNotFoundError
    GetSessionDetailsRequestInternalServerError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: GetSessionDetailsRequestInternalServerError
    CommandRequest:
      type: object
      properties:
        operation_uuid:
          type: string
          format: uuid
          description: >-
            Optional caller-supplied per-command correlation id, a bare lowercase RFC-4122 v4 UUID (no prefix). Echoed
            back as `operation_uuid` in the 202 ack. A later lifecycle webhook carries it only when the gateway can
            unambiguously associate that event with this command; the field is correlation, not proof of causation. When
            omitted, the gateway mints one. Not an idempotency key — request deduplication is the `Idempotency-Key`
            header. Invalid input (not a v4 UUID) is rejected with `400 invalid_request`.
      title: CommandRequest
    AsyncCommandResponseStatus:
      type: string
      enum:
        - in_progress
        - completed
      title: AsyncCommandResponseStatus
    AsyncCommandResponse:
      type: object
      properties:
        operation_uuid:
          type: string
          format: uuid
        status:
          $ref: '#/components/schemas/AsyncCommandResponseStatus'
        already_ended:
          type: boolean
          enum:
            - true
          description: >-
            Optional. Set to `true` on idempotent terminal commands when the session was already in a terminal state at
            the time the request was received. Absent otherwise.
      required:
        - operation_uuid
        - status
      description: >-
        202 Accepted body for an async command. The command's success/failure is delivered later as a domain lifecycle
        webhook (e.g. `playback.started`/`stopped`/`failed`, `command.recording.start.accepted`, `digits.collected`,
        `session.answered`/`session.ended`). A lifecycle event carries `operation_uuid` only when it can be
        unambiguously associated with the submitted command — not as a generic ack on this response.
      title: AsyncCommandResponse
    V1SessionsUuidAnswerPostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
        - internal
      description: >-
        Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
        handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
        `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
        `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
        `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


        Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
        size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
        query with filters and retry).


        Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
        conditions: `502` means a command dependency could not accept the request, `503` means a required service
        (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no
        spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
      title: V1SessionsUuidAnswerPostResponsesContentApplicationJsonSchemaCode
    AnswerACallRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidAnswerPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: AnswerACallRequestBadRequestError
    AnswerACallRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidAnswerPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: AnswerACallRequestUnauthorizedError
    AnswerACallRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidAnswerPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: AnswerACallRequestNotFoundError
    AnswerACallRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidAnswerPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: AnswerACallRequestConflictError
    AnswerACallRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidAnswerPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: AnswerACallRequestContentTooLargeError
    AnswerACallRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidAnswerPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: AnswerACallRequestUnsupportedMediaTypeError
    AnswerACallRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidAnswerPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: AnswerACallRequestUnprocessableEntityError
    AnswerACallRequestInternalServerError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidAnswerPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: AnswerACallRequestInternalServerError
    AnswerACallRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidAnswerPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: AnswerACallRequestServiceUnavailableError
    V1SessionsUuidDeleteResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
        - internal
      description: >-
        Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
        handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
        `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
        `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
        `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


        Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
        size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
        query with filters and retry).


        Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
        conditions: `502` means a command dependency could not accept the request, `503` means a required service
        (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no
        spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
      title: V1SessionsUuidDeleteResponsesContentApplicationJsonSchemaCode
    DeleteSessionRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidDeleteResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: DeleteSessionRequestBadRequestError
    DeleteSessionRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidDeleteResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: DeleteSessionRequestUnauthorizedError
    DeleteSessionRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidDeleteResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: DeleteSessionRequestNotFoundError
    DeleteSessionRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidDeleteResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: DeleteSessionRequestConflictError
    DeleteSessionRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidDeleteResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: DeleteSessionRequestContentTooLargeError
    DeleteSessionRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidDeleteResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: DeleteSessionRequestUnsupportedMediaTypeError
    DeleteSessionRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidDeleteResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: DeleteSessionRequestUnprocessableEntityError
    DeleteSessionRequestInternalServerError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidDeleteResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: DeleteSessionRequestInternalServerError
    DeleteSessionRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidDeleteResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: DeleteSessionRequestServiceUnavailableError
    RoomSummary:
      type: object
      properties:
        created_at:
          type: string
          format: date-time
          description: RFC 3339 / ISO 8601 UTC room-creation timestamp with a 3-digit millisecond fraction.
        member_count:
          type: integer
          description: Current member count.
        room_id:
          type: string
          description: Unique room identifier.
      required:
        - created_at
        - member_count
        - room_id
      description: The compact room representation returned by the room list.
      title: RoomSummary
    RoomListResponse:
      type: object
      properties:
        has_more:
          type: boolean
          description: |-
            `true` when more rooms matched than `limit` allowed;
            raise `limit` to retrieve all of them.
        rooms:
          type: array
          items:
            $ref: '#/components/schemas/RoomSummary'
      required:
        - has_more
        - rooms
      title: RoomListResponse
    ApiV1RoomsGetResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
        - internal
      description: >-
        Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
        handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
        `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
        `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
        `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


        Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
        size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
        query with filters and retry).


        Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
        conditions: `502` means a command dependency could not accept the request, `503` means a required service
        (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no
        spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
      title: ApiV1RoomsGetResponsesContentApplicationJsonSchemaCode
    ListRoomsRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: ListRoomsRequestBadRequestError
    ListRoomsRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: ListRoomsRequestUnauthorizedError
    ListRoomsRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: ListRoomsRequestContentTooLargeError
    ListRoomsRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - retry_after
        - success
      title: ListRoomsRequestTooManyRequestsError
    ListRoomsRequestInternalServerError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: ListRoomsRequestInternalServerError
    Rooms_createRoom_Response_201:
      type: object
      properties:
        room_id:
          type: string
          description: Unique room identifier (format {prefix}-room-{uuid})
      required:
        - room_id
      title: Rooms_createRoom_Response_201
    ApiV1RoomsPostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
        - internal
      description: >-
        Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
        handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
        `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
        `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
        `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


        Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
        size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
        query with filters and retry).


        Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
        conditions: `502` means a command dependency could not accept the request, `503` means a required service
        (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no
        spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
      title: ApiV1RoomsPostResponsesContentApplicationJsonSchemaCode
    CreateRoomRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: CreateRoomRequestBadRequestError
    CreateRoomRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: CreateRoomRequestUnauthorizedError
    CreateRoomRequestForbiddenError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: CreateRoomRequestForbiddenError
    CreateRoomRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: CreateRoomRequestConflictError
    CreateRoomRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: CreateRoomRequestContentTooLargeError
    CreateRoomRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: CreateRoomRequestUnsupportedMediaTypeError
    CreateRoomRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: CreateRoomRequestUnprocessableEntityError
    CreateRoomRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - retry_after
        - success
      title: CreateRoomRequestTooManyRequestsError
    CreateRoomRequestInternalServerError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: CreateRoomRequestInternalServerError
    CreateRoomRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: CreateRoomRequestServiceUnavailableError
    ApiV1RoomsRoomIdDeleteResponsesContentApplicationJsonSchemaStatus:
      type: string
      enum:
        - deleting
      title: ApiV1RoomsRoomIdDeleteResponsesContentApplicationJsonSchemaStatus
    Rooms_deleteRoom_Response_202:
      type: object
      properties:
        room_id:
          type: string
        status:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdDeleteResponsesContentApplicationJsonSchemaStatus'
      required:
        - room_id
        - status
      title: Rooms_deleteRoom_Response_202
    ApiV1RoomsRoomIdDeleteResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
        - internal
      description: >-
        Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
        handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
        `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
        `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
        `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


        Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
        size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
        query with filters and retry).


        Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
        conditions: `502` means a command dependency could not accept the request, `503` means a required service
        (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no
        spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
      title: ApiV1RoomsRoomIdDeleteResponsesContentApplicationJsonSchemaCode
    DeleteRoomRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdDeleteResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: DeleteRoomRequestBadRequestError
    DeleteRoomRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdDeleteResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: DeleteRoomRequestUnauthorizedError
    DeleteRoomRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdDeleteResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: DeleteRoomRequestNotFoundError
    DeleteRoomRequestInternalServerError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdDeleteResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: DeleteRoomRequestInternalServerError
    RoomPlaybackStatus:
      type: string
      enum:
        - stopped
        - playing
        - paused
      title: RoomPlaybackStatus
    Room:
      type: object
      properties:
        created_at:
          type: string
          format: date-time
        member_count:
          type: integer
          description: Current number of members in the room.
        playback_operation_uuid:
          type: string
        playback_status:
          $ref: '#/components/schemas/RoomPlaybackStatus'
        playback_urls:
          type: array
          items:
            type: string
        playback_volume:
          type: integer
          default: 0
          description: |-
            Current room playback volume (0-200). A newly created room reports
            `0` until a room playback volume command sets an explicit value.
        room_id:
          type: string
      required:
        - created_at
        - member_count
        - playback_operation_uuid
        - playback_status
        - playback_urls
        - playback_volume
        - room_id
      title: Room
    ApiV1RoomsRoomIdGetResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
        - internal
      description: >-
        Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
        handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
        `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
        `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
        `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


        Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
        size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
        query with filters and retry).


        Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
        conditions: `502` means a command dependency could not accept the request, `503` means a required service
        (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no
        spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
      title: ApiV1RoomsRoomIdGetResponsesContentApplicationJsonSchemaCode
    GetRoomStatusRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: GetRoomStatusRequestBadRequestError
    GetRoomStatusRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: GetRoomStatusRequestUnauthorizedError
    GetRoomStatusRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: GetRoomStatusRequestNotFoundError
    GetRoomStatusRequestInternalServerError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: GetRoomStatusRequestInternalServerError
    RoomMember:
      type: object
      properties:
        muted:
          type: boolean
          description: Whether the member is currently muted in the room.
        uuid:
          type: string
          description: Session UUID of the member.
      required:
        - muted
        - uuid
      description: |-
        A session's current membership state in a room. The `uuid` is the
        corresponding session UUID and is the stable identity of the member.
      title: RoomMember
    RoomMemberListResponse:
      type: object
      properties:
        has_more:
          type: boolean
          description: |-
            `true` when more members matched than `limit` allowed;
            raise `limit` to retrieve all of them.
        members:
          type: array
          items:
            $ref: '#/components/schemas/RoomMember'
        room_id:
          type: string
      required:
        - has_more
        - members
        - room_id
      title: RoomMemberListResponse
    ApiV1RoomsRoomIdMembersGetResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
        - internal
      description: >-
        Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
        handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
        `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
        `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
        `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


        Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
        size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
        query with filters and retry).


        Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
        conditions: `502` means a command dependency could not accept the request, `503` means a required service
        (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no
        spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
      title: ApiV1RoomsRoomIdMembersGetResponsesContentApplicationJsonSchemaCode
    ListRoomMembersRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdMembersGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: ListRoomMembersRequestBadRequestError
    ListRoomMembersRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdMembersGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: ListRoomMembersRequestUnauthorizedError
    ListRoomMembersRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdMembersGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: ListRoomMembersRequestNotFoundError
    ListRoomMembersRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdMembersGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: ListRoomMembersRequestContentTooLargeError
    ListRoomMembersRequestInternalServerError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdMembersGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: ListRoomMembersRequestInternalServerError
    ApiV1RoomsRoomIdMembersPostResponsesContentApplicationJsonSchemaStatus:
      type: string
      enum:
        - joining
      title: ApiV1RoomsRoomIdMembersPostResponsesContentApplicationJsonSchemaStatus
    Room Members_addRoomMember_Response_200:
      type: object
      properties:
        room_id:
          type: string
        status:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdMembersPostResponsesContentApplicationJsonSchemaStatus'
      required:
        - room_id
        - status
      title: Room Members_addRoomMember_Response_200
    ApiV1RoomsRoomIdMembersPostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
        - internal
      description: >-
        Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
        handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
        `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
        `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
        `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


        Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
        size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
        query with filters and retry).


        Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
        conditions: `502` means a command dependency could not accept the request, `503` means a required service
        (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no
        spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
      title: ApiV1RoomsRoomIdMembersPostResponsesContentApplicationJsonSchemaCode
    AddRoomMemberRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdMembersPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: AddRoomMemberRequestBadRequestError
    AddRoomMemberRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdMembersPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: AddRoomMemberRequestUnauthorizedError
    AddRoomMemberRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdMembersPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: AddRoomMemberRequestNotFoundError
    ErrorResponseCode:
      type: string
      enum:
        - invalid_request
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
        - internal
      description: >-
        Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
        handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
        `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
        `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
        `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


        Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
        size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
        query with filters and retry).


        Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
        conditions: `502` means a command dependency could not accept the request, `503` means a required service
        (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no
        spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
      title: ErrorResponseCode
    ErrorResponse:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ErrorResponseCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: ErrorResponse
    AddRoomMemberRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdMembersPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: AddRoomMemberRequestContentTooLargeError
    AddRoomMemberRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdMembersPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: AddRoomMemberRequestUnsupportedMediaTypeError
    AddRoomMemberRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdMembersPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: AddRoomMemberRequestUnprocessableEntityError
    AddRoomMemberRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdMembersPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - retry_after
        - success
      title: AddRoomMemberRequestTooManyRequestsError
    AddRoomMemberRequestInternalServerError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdMembersPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: AddRoomMemberRequestInternalServerError
    AddRoomMemberRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdMembersPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: AddRoomMemberRequestServiceUnavailableError
    ApiV1RoomsRoomIdMembersUuidGetResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
        - internal
      description: >-
        Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
        handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
        `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
        `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
        `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


        Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
        size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
        query with filters and retry).


        Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
        conditions: `502` means a command dependency could not accept the request, `503` means a required service
        (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no
        spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
      title: ApiV1RoomsRoomIdMembersUuidGetResponsesContentApplicationJsonSchemaCode
    GetRoomMemberRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdMembersUuidGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: GetRoomMemberRequestBadRequestError
    GetRoomMemberRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdMembersUuidGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: GetRoomMemberRequestUnauthorizedError
    GetRoomMemberRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdMembersUuidGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: GetRoomMemberRequestNotFoundError
    GetRoomMemberRequestInternalServerError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdMembersUuidGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: GetRoomMemberRequestInternalServerError
    ApiV1RoomsRoomIdMembersUuidDeleteResponsesContentApplicationJsonSchemaStatus:
      type: string
      enum:
        - leaving
      title: ApiV1RoomsRoomIdMembersUuidDeleteResponsesContentApplicationJsonSchemaStatus
    Room Members_removeRoomMember_Response_202:
      type: object
      properties:
        room_id:
          type: string
        status:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdMembersUuidDeleteResponsesContentApplicationJsonSchemaStatus'
      required:
        - room_id
        - status
      title: Room Members_removeRoomMember_Response_202
    ApiV1RoomsRoomIdMembersUuidDeleteResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
        - internal
      description: >-
        Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
        handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
        `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
        `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
        `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


        Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
        size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
        query with filters and retry).


        Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
        conditions: `502` means a command dependency could not accept the request, `503` means a required service
        (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no
        spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
      title: ApiV1RoomsRoomIdMembersUuidDeleteResponsesContentApplicationJsonSchemaCode
    RemoveRoomMemberRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdMembersUuidDeleteResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: RemoveRoomMemberRequestBadRequestError
    RemoveRoomMemberRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdMembersUuidDeleteResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: RemoveRoomMemberRequestUnauthorizedError
    RemoveRoomMemberRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdMembersUuidDeleteResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: RemoveRoomMemberRequestNotFoundError
    RemoveRoomMemberRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdMembersUuidDeleteResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: RemoveRoomMemberRequestConflictError
    RemoveRoomMemberRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdMembersUuidDeleteResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - retry_after
        - success
      title: RemoveRoomMemberRequestTooManyRequestsError
    RemoveRoomMemberRequestInternalServerError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdMembersUuidDeleteResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: RemoveRoomMemberRequestInternalServerError
    V1SessionsUuidRoomMutePostResponsesContentApplicationJsonSchemaStatus:
      type: string
      enum:
        - muted
      title: V1SessionsUuidRoomMutePostResponsesContentApplicationJsonSchemaStatus
    Room Members_muteRoomMember_Response_202:
      type: object
      properties:
        room_id:
          type: string
        status:
          $ref: '#/components/schemas/V1SessionsUuidRoomMutePostResponsesContentApplicationJsonSchemaStatus'
      required:
        - room_id
        - status
      title: Room Members_muteRoomMember_Response_202
    V1SessionsUuidRoomMutePostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
        - internal
      description: >-
        Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
        handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
        `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
        `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
        `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


        Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
        size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
        query with filters and retry).


        Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
        conditions: `502` means a command dependency could not accept the request, `503` means a required service
        (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no
        spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
      title: V1SessionsUuidRoomMutePostResponsesContentApplicationJsonSchemaCode
    MuteRoomMemberRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRoomMutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: MuteRoomMemberRequestBadRequestError
    MuteRoomMemberRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRoomMutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: MuteRoomMemberRequestUnauthorizedError
    MuteRoomMemberRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRoomMutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: MuteRoomMemberRequestNotFoundError
    MuteRoomMemberRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRoomMutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: MuteRoomMemberRequestContentTooLargeError
    MuteRoomMemberRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRoomMutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: MuteRoomMemberRequestUnsupportedMediaTypeError
    MuteRoomMemberRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRoomMutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: MuteRoomMemberRequestUnprocessableEntityError
    MuteRoomMemberRequestInternalServerError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRoomMutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: MuteRoomMemberRequestInternalServerError
    MuteRoomMemberRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRoomMutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: MuteRoomMemberRequestServiceUnavailableError
    V1SessionsUuidRoomUnmutePostResponsesContentApplicationJsonSchemaStatus:
      type: string
      enum:
        - unmuted
      title: V1SessionsUuidRoomUnmutePostResponsesContentApplicationJsonSchemaStatus
    Room Members_unmuteRoomMember_Response_202:
      type: object
      properties:
        room_id:
          type: string
        status:
          $ref: '#/components/schemas/V1SessionsUuidRoomUnmutePostResponsesContentApplicationJsonSchemaStatus'
      required:
        - room_id
        - status
      title: Room Members_unmuteRoomMember_Response_202
    V1SessionsUuidRoomUnmutePostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
        - internal
      description: >-
        Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
        handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
        `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
        `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
        `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


        Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
        size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
        query with filters and retry).


        Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
        conditions: `502` means a command dependency could not accept the request, `503` means a required service
        (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no
        spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
      title: V1SessionsUuidRoomUnmutePostResponsesContentApplicationJsonSchemaCode
    UnmuteRoomMemberRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRoomUnmutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: UnmuteRoomMemberRequestBadRequestError
    UnmuteRoomMemberRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRoomUnmutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: UnmuteRoomMemberRequestUnauthorizedError
    UnmuteRoomMemberRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRoomUnmutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: UnmuteRoomMemberRequestNotFoundError
    UnmuteRoomMemberRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRoomUnmutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: UnmuteRoomMemberRequestContentTooLargeError
    UnmuteRoomMemberRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRoomUnmutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: UnmuteRoomMemberRequestUnsupportedMediaTypeError
    UnmuteRoomMemberRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRoomUnmutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: UnmuteRoomMemberRequestUnprocessableEntityError
    UnmuteRoomMemberRequestInternalServerError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRoomUnmutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: UnmuteRoomMemberRequestInternalServerError
    UnmuteRoomMemberRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRoomUnmutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: UnmuteRoomMemberRequestServiceUnavailableError
    V1SessionsUuidRoomVolumePostRequestBodyContentApplicationJsonSchemaDirection:
      type: string
      enum:
        - in
        - out
        - both
      description: Which side to adjust. out = member hears room; in = member heard by room; both = both.
      title: V1SessionsUuidRoomVolumePostRequestBodyContentApplicationJsonSchemaDirection
    V1SessionsUuidRoomVolumePostResponsesContentApplicationJsonSchemaStatus:
      type: string
      enum:
        - volume_set
      title: V1SessionsUuidRoomVolumePostResponsesContentApplicationJsonSchemaStatus
    Room Members_setRoomMemberVolume_Response_202:
      type: object
      properties:
        room_id:
          type: string
        status:
          $ref: '#/components/schemas/V1SessionsUuidRoomVolumePostResponsesContentApplicationJsonSchemaStatus'
      required:
        - room_id
        - status
      title: Room Members_setRoomMemberVolume_Response_202
    V1SessionsUuidRoomVolumePostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
        - internal
      description: >-
        Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
        handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
        `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
        `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
        `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


        Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
        size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
        query with filters and retry).


        Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
        conditions: `502` means a command dependency could not accept the request, `503` means a required service
        (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no
        spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
      title: V1SessionsUuidRoomVolumePostResponsesContentApplicationJsonSchemaCode
    SetRoomMemberVolumeRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRoomVolumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: SetRoomMemberVolumeRequestBadRequestError
    SetRoomMemberVolumeRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRoomVolumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: SetRoomMemberVolumeRequestUnauthorizedError
    SetRoomMemberVolumeRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRoomVolumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: SetRoomMemberVolumeRequestContentTooLargeError
    SetRoomMemberVolumeRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRoomVolumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: SetRoomMemberVolumeRequestUnsupportedMediaTypeError
    SetRoomMemberVolumeRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRoomVolumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: SetRoomMemberVolumeRequestUnprocessableEntityError
    SetRoomMemberVolumeRequestInternalServerError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRoomVolumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: SetRoomMemberVolumeRequestInternalServerError
    SetRoomMemberVolumeRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRoomVolumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: SetRoomMemberVolumeRequestServiceUnavailableError
    RoomAsyncCommandResponseStatus:
      type: string
      enum:
        - in_progress
      title: RoomAsyncCommandResponseStatus
    RoomAsyncCommandResponse:
      type: object
      properties:
        operation_uuid:
          type: string
          format: uuid
        status:
          $ref: '#/components/schemas/RoomAsyncCommandResponseStatus'
      required:
        - operation_uuid
        - status
      description: 202 Accepted body for an asynchronous room playback command.
      title: RoomAsyncCommandResponse
    ApiV1RoomsRoomIdPlaybackPausePostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
        - internal
      description: >-
        Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
        handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
        `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
        `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
        `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


        Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
        size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
        query with filters and retry).


        Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
        conditions: `502` means a command dependency could not accept the request, `503` means a required service
        (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no
        spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
      title: ApiV1RoomsRoomIdPlaybackPausePostResponsesContentApplicationJsonSchemaCode
    PauseRoomPlaybackRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackPausePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: PauseRoomPlaybackRequestBadRequestError
    PauseRoomPlaybackRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackPausePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: PauseRoomPlaybackRequestUnauthorizedError
    PauseRoomPlaybackRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackPausePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: PauseRoomPlaybackRequestNotFoundError
    PauseRoomPlaybackRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackPausePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - retry_after
        - success
      title: PauseRoomPlaybackRequestTooManyRequestsError
    PauseRoomPlaybackRequestInternalServerError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackPausePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: PauseRoomPlaybackRequestInternalServerError
    PauseRoomPlaybackRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackPausePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: PauseRoomPlaybackRequestServiceUnavailableError
    RoomPlaybackPlayAudioInRoomRequest0:
      type: object
      properties:
        loop:
          type: boolean
          default: false
          description: Replay the finite source from the beginning whenever it finishes.
        offset_ms:
          type: integer
          description: |-
            Optional starting offset in milliseconds. It is valid only
            with one finite source.
        type:
          type: string
          enum:
            - files
          default: files
          description: Selects finite-file playback.
        urls:
          type: array
          items:
            type: string
            format: uri
          description: |-
            HTTP/HTTPS URLs of audio files to play sequentially. With two
            or more URLs, playback is one continuous playlist, but seeking
            across playlist file boundaries is undefined.
      required:
        - urls
      title: RoomPlaybackPlayAudioInRoomRequest0
    RoomPlaybackPlayAudioInRoomRequest1:
      type: object
      properties:
        type:
          type: string
          enum:
            - stream
          description: Selects live-stream playback.
        url:
          type: string
          format: uri
          description: The single live HTTP/HTTPS stream to play.
      required:
        - type
        - url
      title: RoomPlaybackPlayAudioInRoomRequest1
    Room Playback_playAudioInRoom_Request:
      oneOf:
        - $ref: '#/components/schemas/RoomPlaybackPlayAudioInRoomRequest0'
        - $ref: '#/components/schemas/RoomPlaybackPlayAudioInRoomRequest1'
      description: Audio source. `files` uses `urls`; `stream` uses one `url`. The two shapes cannot be mixed.
      title: Room Playback_playAudioInRoom_Request
    ApiV1RoomsRoomIdPlaybackPlayPostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
        - internal
      description: >-
        Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
        handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
        `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
        `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
        `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


        Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
        size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
        query with filters and retry).


        Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
        conditions: `502` means a command dependency could not accept the request, `503` means a required service
        (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no
        spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
      title: ApiV1RoomsRoomIdPlaybackPlayPostResponsesContentApplicationJsonSchemaCode
    PlayAudioInRoomRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackPlayPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: PlayAudioInRoomRequestBadRequestError
    PlayAudioInRoomRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackPlayPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: PlayAudioInRoomRequestUnauthorizedError
    PlayAudioInRoomRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackPlayPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: PlayAudioInRoomRequestNotFoundError
    PlayAudioInRoomRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackPlayPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: PlayAudioInRoomRequestConflictError
    PlayAudioInRoomRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackPlayPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: PlayAudioInRoomRequestContentTooLargeError
    PlayAudioInRoomRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackPlayPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: PlayAudioInRoomRequestUnsupportedMediaTypeError
    PlayAudioInRoomRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackPlayPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: PlayAudioInRoomRequestUnprocessableEntityError
    PlayAudioInRoomRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackPlayPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - retry_after
        - success
      title: PlayAudioInRoomRequestTooManyRequestsError
    PlayAudioInRoomRequestInternalServerError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackPlayPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: PlayAudioInRoomRequestInternalServerError
    PlayAudioInRoomRequestBadGatewayError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackPlayPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: PlayAudioInRoomRequestBadGatewayError
    PlayAudioInRoomRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackPlayPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: PlayAudioInRoomRequestServiceUnavailableError
    ApiV1RoomsRoomIdPlaybackRecordPostResponsesContentApplicationJsonSchemaStatus:
      type: string
      enum:
        - in_progress
      title: ApiV1RoomsRoomIdPlaybackRecordPostResponsesContentApplicationJsonSchemaStatus
    RecordingURLReference:
      type: string
      format: uri
      description: |-
        Opaque, time-bounded absolute HTTPS recording URL. The default validity
        window is 24 hours from the response or event that emits it. Operators
        can configure any positive duration. Fetching does not extend the window.
      title: RecordingURLReference
    Room Playback_startRoomRecording_Response_202:
      type: object
      properties:
        operation_uuid:
          type: string
          format: uuid
        status:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackRecordPostResponsesContentApplicationJsonSchemaStatus'
        recording_uuid:
          type: string
          description: Stable opaque identifier for this Recording.
        room_id:
          type: string
          description: Owning [Room](/api/rooms); mutually exclusive with `session_uuid`.
        session_uuid:
          type: string
          description: Owning [Session](/api/sessions); mutually exclusive with `room_id`.
        expires_at:
          type: string
          format: date-time
          description: Exact expiry instant of pull_url, derived from the URL's signed expiration.
        pull_url:
          $ref: '#/components/schemas/RecordingURLReference'
          description: |-
            Fetches the whole Recording so far. Its configurable validity
            window defaults to 24 hours from this response's emission.
      required:
        - operation_uuid
        - status
        - recording_uuid
        - expires_at
        - pull_url
      description: Flat accepted response for a room Recording start.
      title: Room Playback_startRoomRecording_Response_202
    ApiV1RoomsRoomIdPlaybackRecordPostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
        - internal
      description: >-
        Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
        handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
        `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
        `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
        `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


        Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
        size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
        query with filters and retry).


        Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
        conditions: `502` means a command dependency could not accept the request, `503` means a required service
        (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no
        spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
      title: ApiV1RoomsRoomIdPlaybackRecordPostResponsesContentApplicationJsonSchemaCode
    StartRoomRecordingRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackRecordPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StartRoomRecordingRequestBadRequestError
    StartRoomRecordingRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackRecordPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StartRoomRecordingRequestUnauthorizedError
    StartRoomRecordingRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackRecordPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StartRoomRecordingRequestNotFoundError
    StartRoomRecordingRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackRecordPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StartRoomRecordingRequestConflictError
    StartRoomRecordingRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackRecordPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StartRoomRecordingRequestUnprocessableEntityError
    StartRoomRecordingRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackRecordPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - retry_after
        - success
      title: StartRoomRecordingRequestTooManyRequestsError
    StartRoomRecordingRequestInternalServerError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackRecordPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StartRoomRecordingRequestInternalServerError
    StartRoomRecordingRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackRecordPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StartRoomRecordingRequestServiceUnavailableError
    ApiV1RoomsRoomIdPlaybackRecordStopPostResponsesContentApplicationJsonSchemaStatus:
      type: string
      enum:
        - in_progress
      title: ApiV1RoomsRoomIdPlaybackRecordStopPostResponsesContentApplicationJsonSchemaStatus
    Room Playback_stopRoomRecording_Response_202:
      type: object
      properties:
        operation_uuid:
          type: string
          format: uuid
        status:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackRecordStopPostResponsesContentApplicationJsonSchemaStatus'
        recording_uuid:
          type: string
          description: Stable opaque identifier for this Recording.
        room_id:
          type: string
          description: Owning [Room](/api/rooms); mutually exclusive with `session_uuid`.
        session_uuid:
          type: string
          description: Owning [Session](/api/sessions); mutually exclusive with `room_id`.
        expires_at:
          type: string
          format: date-time
          description: Exact expiry instant of pull_url, derived from the URL's signed expiration.
        pull_url:
          $ref: '#/components/schemas/RecordingURLReference'
          description: |-
            Fresh whole-Recording download URL. Its configurable validity
            window defaults to 24 hours from this response's emission.
      required:
        - operation_uuid
        - status
        - recording_uuid
        - expires_at
        - pull_url
      description: Flat accepted response for a room Recording stop.
      title: Room Playback_stopRoomRecording_Response_202
    ApiV1RoomsRoomIdPlaybackRecordStopPostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
        - internal
      description: >-
        Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
        handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
        `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
        `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
        `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


        Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
        size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
        query with filters and retry).


        Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
        conditions: `502` means a command dependency could not accept the request, `503` means a required service
        (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no
        spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
      title: ApiV1RoomsRoomIdPlaybackRecordStopPostResponsesContentApplicationJsonSchemaCode
    StopRoomRecordingRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackRecordStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StopRoomRecordingRequestBadRequestError
    StopRoomRecordingRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackRecordStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StopRoomRecordingRequestUnauthorizedError
    StopRoomRecordingRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackRecordStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StopRoomRecordingRequestNotFoundError
    StopRoomRecordingRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackRecordStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StopRoomRecordingRequestConflictError
    StopRoomRecordingRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackRecordStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - retry_after
        - success
      title: StopRoomRecordingRequestTooManyRequestsError
    StopRoomRecordingRequestInternalServerError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackRecordStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StopRoomRecordingRequestInternalServerError
    StopRoomRecordingRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackRecordStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StopRoomRecordingRequestServiceUnavailableError
    ApiV1RoomsRoomIdPlaybackSeekPostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
        - internal
      description: >-
        Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
        handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
        `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
        `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
        `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


        Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
        size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
        query with filters and retry).


        Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
        conditions: `502` means a command dependency could not accept the request, `503` means a required service
        (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no
        spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
      title: ApiV1RoomsRoomIdPlaybackSeekPostResponsesContentApplicationJsonSchemaCode
    SeekRoomPlaybackRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackSeekPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: SeekRoomPlaybackRequestBadRequestError
    SeekRoomPlaybackRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackSeekPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: SeekRoomPlaybackRequestUnauthorizedError
    SeekRoomPlaybackRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackSeekPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: SeekRoomPlaybackRequestNotFoundError
    SeekRoomPlaybackRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackSeekPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: SeekRoomPlaybackRequestConflictError
    SeekRoomPlaybackRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackSeekPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: SeekRoomPlaybackRequestContentTooLargeError
    SeekRoomPlaybackRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackSeekPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: SeekRoomPlaybackRequestUnsupportedMediaTypeError
    SeekRoomPlaybackRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackSeekPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: SeekRoomPlaybackRequestUnprocessableEntityError
    SeekRoomPlaybackRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackSeekPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - retry_after
        - success
      title: SeekRoomPlaybackRequestTooManyRequestsError
    SeekRoomPlaybackRequestInternalServerError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackSeekPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: SeekRoomPlaybackRequestInternalServerError
    SeekRoomPlaybackRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackSeekPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: SeekRoomPlaybackRequestServiceUnavailableError
    ApiV1RoomsRoomIdPlaybackStopPostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
        - internal
      description: >-
        Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
        handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
        `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
        `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
        `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


        Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
        size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
        query with filters and retry).


        Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
        conditions: `502` means a command dependency could not accept the request, `503` means a required service
        (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no
        spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
      title: ApiV1RoomsRoomIdPlaybackStopPostResponsesContentApplicationJsonSchemaCode
    StopRoomPlaybackRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StopRoomPlaybackRequestBadRequestError
    StopRoomPlaybackRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StopRoomPlaybackRequestUnauthorizedError
    StopRoomPlaybackRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StopRoomPlaybackRequestNotFoundError
    StopRoomPlaybackRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StopRoomPlaybackRequestConflictError
    StopRoomPlaybackRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - retry_after
        - success
      title: StopRoomPlaybackRequestTooManyRequestsError
    StopRoomPlaybackRequestInternalServerError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StopRoomPlaybackRequestInternalServerError
    StopRoomPlaybackRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StopRoomPlaybackRequestServiceUnavailableError
    ApiV1RoomsRoomIdPlaybackVolumePostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
        - internal
      description: >-
        Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
        handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
        `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
        `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
        `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


        Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
        size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
        query with filters and retry).


        Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
        conditions: `502` means a command dependency could not accept the request, `503` means a required service
        (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no
        spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
      title: ApiV1RoomsRoomIdPlaybackVolumePostResponsesContentApplicationJsonSchemaCode
    SetRoomVolumeRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackVolumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: SetRoomVolumeRequestBadRequestError
    SetRoomVolumeRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackVolumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: SetRoomVolumeRequestUnauthorizedError
    SetRoomVolumeRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackVolumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: SetRoomVolumeRequestNotFoundError
    SetRoomVolumeRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackVolumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: SetRoomVolumeRequestConflictError
    SetRoomVolumeRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackVolumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: SetRoomVolumeRequestContentTooLargeError
    SetRoomVolumeRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackVolumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: SetRoomVolumeRequestUnsupportedMediaTypeError
    SetRoomVolumeRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackVolumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: SetRoomVolumeRequestUnprocessableEntityError
    SetRoomVolumeRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackVolumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - retry_after
        - success
      title: SetRoomVolumeRequestTooManyRequestsError
    SetRoomVolumeRequestInternalServerError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackVolumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: SetRoomVolumeRequestInternalServerError
    SetRoomVolumeRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackVolumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: SetRoomVolumeRequestServiceUnavailableError
    V1SessionsUuidRecordingMaskPostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
        - internal
      description: >-
        Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
        handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
        `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
        `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
        `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


        Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
        size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
        query with filters and retry).


        Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
        conditions: `502` means a command dependency could not accept the request, `503` means a required service
        (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no
        spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
      title: V1SessionsUuidRecordingMaskPostResponsesContentApplicationJsonSchemaCode
    MaskRecordingRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingMaskPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: MaskRecordingRequestBadRequestError
    MaskRecordingRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingMaskPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: MaskRecordingRequestUnauthorizedError
    MaskRecordingRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingMaskPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: MaskRecordingRequestNotFoundError
    MaskRecordingRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingMaskPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: MaskRecordingRequestConflictError
    MaskRecordingRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingMaskPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: MaskRecordingRequestContentTooLargeError
    MaskRecordingRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingMaskPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: MaskRecordingRequestUnsupportedMediaTypeError
    MaskRecordingRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingMaskPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: MaskRecordingRequestUnprocessableEntityError
    MaskRecordingRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingMaskPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - retry_after
        - success
      title: MaskRecordingRequestTooManyRequestsError
    MaskRecordingRequestInternalServerError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingMaskPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: MaskRecordingRequestInternalServerError
    MaskRecordingRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingMaskPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: MaskRecordingRequestServiceUnavailableError
    V1SessionsUuidRecordingStartPostRequestBodyContentApplicationJsonSchemaVoiceActivityConfig:
      type: object
      properties:
        sensitivity:
          type: integer
          description: |-
            Detection sensitivity. Lower values are more resistant to
            background noise but can miss quiet speech. Higher values
            detect quieter or more distant speech but increase the
            chance that background noise is classified as speech. Start
            around 25 for noisy environments, 50 for ordinary calls,
            or 75 for quiet or distant speakers.
        silence_duration_ms:
          type: integer
          description: |-
            Continuous silence, in milliseconds, before
            `recording.speech.ended`. Lower values end faster but can
            split natural pauses; higher values preserve pauses but
            delay the end event. Durations are evaluated at media-frame
            granularity, so transitions can take roughly one additional
            frame plus webhook delivery.
        speech_duration_ms:
          type: integer
          description: |-
            Minimum continuous speech, in milliseconds, before
            `recording.speech.started`. Lower values react faster but
            admit short noises; higher values reject transient sounds
            but delay the start event.
      required:
        - sensitivity
        - silence_duration_ms
        - speech_duration_ms
      description: |-
        Required tuning when voice activity events are enabled. Supplying
        this object requires
        `enable_voice_activity_events: true`; otherwise the request is
        rejected.
      title: V1SessionsUuidRecordingStartPostRequestBodyContentApplicationJsonSchemaVoiceActivityConfig
    V1SessionsUuidRecordingStartPostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
        - internal
      description: >-
        Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
        handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
        `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
        `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
        `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


        Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
        size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
        query with filters and retry).


        Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
        conditions: `502` means a command dependency could not accept the request, `503` means a required service
        (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no
        spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
      title: V1SessionsUuidRecordingStartPostResponsesContentApplicationJsonSchemaCode
    StartRecordingRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingStartPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StartRecordingRequestBadRequestError
    StartRecordingRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingStartPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StartRecordingRequestUnauthorizedError
    StartRecordingRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingStartPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StartRecordingRequestNotFoundError
    StartRecordingRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingStartPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StartRecordingRequestConflictError
    StartRecordingRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingStartPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StartRecordingRequestContentTooLargeError
    StartRecordingRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingStartPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StartRecordingRequestUnsupportedMediaTypeError
    StartRecordingRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingStartPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StartRecordingRequestUnprocessableEntityError
    StartRecordingRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingStartPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - retry_after
        - success
      title: StartRecordingRequestTooManyRequestsError
    StartRecordingRequestInternalServerError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingStartPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StartRecordingRequestInternalServerError
    StartRecordingRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingStartPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StartRecordingRequestServiceUnavailableError
    V1SessionsUuidRecordingStopPostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
        - internal
      description: >-
        Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
        handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
        `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
        `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
        `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


        Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
        size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
        query with filters and retry).


        Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
        conditions: `502` means a command dependency could not accept the request, `503` means a required service
        (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no
        spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
      title: V1SessionsUuidRecordingStopPostResponsesContentApplicationJsonSchemaCode
    StopRecordingRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StopRecordingRequestBadRequestError
    StopRecordingRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StopRecordingRequestUnauthorizedError
    StopRecordingRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StopRecordingRequestNotFoundError
    StopRecordingRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StopRecordingRequestConflictError
    StopRecordingRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StopRecordingRequestContentTooLargeError
    StopRecordingRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StopRecordingRequestUnsupportedMediaTypeError
    StopRecordingRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StopRecordingRequestUnprocessableEntityError
    StopRecordingRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - retry_after
        - success
      title: StopRecordingRequestTooManyRequestsError
    StopRecordingRequestInternalServerError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StopRecordingRequestInternalServerError
    StopRecordingRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StopRecordingRequestServiceUnavailableError
    V1SessionsUuidRecordingUnmaskPostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
        - internal
      description: >-
        Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
        handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
        `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
        `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
        `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


        Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
        size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
        query with filters and retry).


        Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
        conditions: `502` means a command dependency could not accept the request, `503` means a required service
        (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no
        spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
      title: V1SessionsUuidRecordingUnmaskPostResponsesContentApplicationJsonSchemaCode
    UnmaskRecordingRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingUnmaskPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: UnmaskRecordingRequestBadRequestError
    UnmaskRecordingRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingUnmaskPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: UnmaskRecordingRequestUnauthorizedError
    UnmaskRecordingRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingUnmaskPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: UnmaskRecordingRequestNotFoundError
    UnmaskRecordingRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingUnmaskPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: UnmaskRecordingRequestConflictError
    UnmaskRecordingRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingUnmaskPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: UnmaskRecordingRequestContentTooLargeError
    UnmaskRecordingRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingUnmaskPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: UnmaskRecordingRequestUnsupportedMediaTypeError
    UnmaskRecordingRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingUnmaskPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: UnmaskRecordingRequestUnprocessableEntityError
    UnmaskRecordingRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingUnmaskPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - retry_after
        - success
      title: UnmaskRecordingRequestTooManyRequestsError
    UnmaskRecordingRequestInternalServerError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingUnmaskPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: UnmaskRecordingRequestInternalServerError
    UnmaskRecordingRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingUnmaskPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: UnmaskRecordingRequestServiceUnavailableError
    V1SessionsUuidWebsocketFlushPostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
        - internal
      description: >-
        Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
        handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
        `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
        `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
        `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


        Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
        size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
        query with filters and retry).


        Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
        conditions: `502` means a command dependency could not accept the request, `503` means a required service
        (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no
        spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
      title: V1SessionsUuidWebsocketFlushPostResponsesContentApplicationJsonSchemaCode
    WsFlushRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketFlushPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsFlushRequestBadRequestError
    WsFlushRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketFlushPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsFlushRequestUnauthorizedError
    WsFlushRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketFlushPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsFlushRequestNotFoundError
    WsFlushRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketFlushPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsFlushRequestConflictError
    WsFlushRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketFlushPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsFlushRequestContentTooLargeError
    WsFlushRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketFlushPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsFlushRequestUnsupportedMediaTypeError
    WsFlushRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketFlushPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsFlushRequestUnprocessableEntityError
    WsFlushRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketFlushPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - retry_after
        - success
      title: WsFlushRequestTooManyRequestsError
    WsFlushRequestInternalServerError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketFlushPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsFlushRequestInternalServerError
    WsFlushRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketFlushPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsFlushRequestServiceUnavailableError
    V1SessionsUuidWebsocketMutePostRequestBodyContentApplicationJsonSchemaLeg:
      type: string
      enum:
        - user
        - backend
        - all
      description: |-
        Which direction the mute/unmute applies to: `user` (audio from the
        caller), `backend` (audio from the backend), or `all`.
      title: V1SessionsUuidWebsocketMutePostRequestBodyContentApplicationJsonSchemaLeg
    V1SessionsUuidWebsocketMutePostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
        - internal
      description: >-
        Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
        handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
        `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
        `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
        `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


        Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
        size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
        query with filters and retry).


        Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
        conditions: `502` means a command dependency could not accept the request, `503` means a required service
        (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no
        spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
      title: V1SessionsUuidWebsocketMutePostResponsesContentApplicationJsonSchemaCode
    WsMuteRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketMutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsMuteRequestBadRequestError
    WsMuteRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketMutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsMuteRequestUnauthorizedError
    WsMuteRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketMutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsMuteRequestNotFoundError
    WsMuteRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketMutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsMuteRequestConflictError
    WsMuteRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketMutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsMuteRequestContentTooLargeError
    WsMuteRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketMutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsMuteRequestUnsupportedMediaTypeError
    WsMuteRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketMutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsMuteRequestUnprocessableEntityError
    WsMuteRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketMutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - retry_after
        - success
      title: WsMuteRequestTooManyRequestsError
    WsMuteRequestInternalServerError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketMutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsMuteRequestInternalServerError
    WsMuteRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketMutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsMuteRequestServiceUnavailableError
    V1SessionsUuidWebsocketPausePostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
        - internal
      description: >-
        Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
        handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
        `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
        `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
        `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


        Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
        size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
        query with filters and retry).


        Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
        conditions: `502` means a command dependency could not accept the request, `503` means a required service
        (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no
        spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
      title: V1SessionsUuidWebsocketPausePostResponsesContentApplicationJsonSchemaCode
    WsPauseRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketPausePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsPauseRequestBadRequestError
    WsPauseRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketPausePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsPauseRequestUnauthorizedError
    WsPauseRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketPausePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsPauseRequestNotFoundError
    WsPauseRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketPausePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsPauseRequestConflictError
    WsPauseRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketPausePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsPauseRequestContentTooLargeError
    WsPauseRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketPausePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsPauseRequestUnsupportedMediaTypeError
    WsPauseRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketPausePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsPauseRequestUnprocessableEntityError
    WsPauseRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketPausePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - retry_after
        - success
      title: WsPauseRequestTooManyRequestsError
    WsPauseRequestInternalServerError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketPausePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsPauseRequestInternalServerError
    WsPauseRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketPausePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsPauseRequestServiceUnavailableError
    V1SessionsUuidWebsocketResumePostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
        - internal
      description: >-
        Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
        handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
        `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
        `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
        `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


        Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
        size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
        query with filters and retry).


        Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
        conditions: `502` means a command dependency could not accept the request, `503` means a required service
        (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no
        spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
      title: V1SessionsUuidWebsocketResumePostResponsesContentApplicationJsonSchemaCode
    WsResumeRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketResumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsResumeRequestBadRequestError
    WsResumeRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketResumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsResumeRequestUnauthorizedError
    WsResumeRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketResumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsResumeRequestNotFoundError
    WsResumeRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketResumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsResumeRequestConflictError
    WsResumeRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketResumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsResumeRequestContentTooLargeError
    WsResumeRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketResumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsResumeRequestUnsupportedMediaTypeError
    WsResumeRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketResumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsResumeRequestUnprocessableEntityError
    WsResumeRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketResumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - retry_after
        - success
      title: WsResumeRequestTooManyRequestsError
    WsResumeRequestInternalServerError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketResumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsResumeRequestInternalServerError
    WsResumeRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketResumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsResumeRequestServiceUnavailableError
    V1SessionsUuidWebsocketStartPostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
        - internal
      description: >-
        Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
        handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
        `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
        `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
        `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


        Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
        size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
        query with filters and retry).


        Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
        conditions: `502` means a command dependency could not accept the request, `503` means a required service
        (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no
        spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
      title: V1SessionsUuidWebsocketStartPostResponsesContentApplicationJsonSchemaCode
    WsStartRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketStartPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsStartRequestBadRequestError
    WsStartRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketStartPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsStartRequestUnauthorizedError
    WsStartRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketStartPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsStartRequestNotFoundError
    WsStartRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketStartPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsStartRequestConflictError
    WsStartRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketStartPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsStartRequestContentTooLargeError
    WsStartRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketStartPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsStartRequestUnsupportedMediaTypeError
    WsStartRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketStartPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsStartRequestUnprocessableEntityError
    WsStartRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketStartPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - retry_after
        - success
      title: WsStartRequestTooManyRequestsError
    WsStartRequestInternalServerError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketStartPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsStartRequestInternalServerError
    WsStartRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketStartPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsStartRequestServiceUnavailableError
    V1SessionsUuidWebsocketStopPostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
        - internal
      description: >-
        Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
        handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
        `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
        `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
        `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


        Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
        size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
        query with filters and retry).


        Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
        conditions: `502` means a command dependency could not accept the request, `503` means a required service
        (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no
        spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
      title: V1SessionsUuidWebsocketStopPostResponsesContentApplicationJsonSchemaCode
    WsStopRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsStopRequestBadRequestError
    WsStopRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsStopRequestUnauthorizedError
    WsStopRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsStopRequestNotFoundError
    WsStopRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsStopRequestConflictError
    WsStopRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsStopRequestContentTooLargeError
    WsStopRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsStopRequestUnsupportedMediaTypeError
    WsStopRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsStopRequestUnprocessableEntityError
    WsStopRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - retry_after
        - success
      title: WsStopRequestTooManyRequestsError
    WsStopRequestInternalServerError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsStopRequestInternalServerError
    WsStopRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsStopRequestServiceUnavailableError
    V1SessionsUuidWebsocketUnmutePostRequestBodyContentApplicationJsonSchemaLeg:
      type: string
      enum:
        - user
        - backend
        - all
      description: |-
        Which direction the mute/unmute applies to: `user` (audio from the
        caller), `backend` (audio from the backend), or `all`.
      title: V1SessionsUuidWebsocketUnmutePostRequestBodyContentApplicationJsonSchemaLeg
    V1SessionsUuidWebsocketUnmutePostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
        - internal
      description: >-
        Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
        handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
        `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
        `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
        `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


        Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
        size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
        query with filters and retry).


        Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
        conditions: `502` means a command dependency could not accept the request, `503` means a required service
        (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no
        spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
      title: V1SessionsUuidWebsocketUnmutePostResponsesContentApplicationJsonSchemaCode
    WsUnmuteRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketUnmutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsUnmuteRequestBadRequestError
    WsUnmuteRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketUnmutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsUnmuteRequestUnauthorizedError
    WsUnmuteRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketUnmutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsUnmuteRequestNotFoundError
    WsUnmuteRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketUnmutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsUnmuteRequestConflictError
    WsUnmuteRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketUnmutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsUnmuteRequestContentTooLargeError
    WsUnmuteRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketUnmutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsUnmuteRequestUnsupportedMediaTypeError
    WsUnmuteRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketUnmutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsUnmuteRequestUnprocessableEntityError
    WsUnmuteRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketUnmutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - retry_after
        - success
      title: WsUnmuteRequestTooManyRequestsError
    WsUnmuteRequestInternalServerError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketUnmutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsUnmuteRequestInternalServerError
    WsUnmuteRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidWebsocketUnmutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: WsUnmuteRequestServiceUnavailableError
    V1SessionsUuidPlaybackPausePostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
        - internal
      description: >-
        Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
        handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
        `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
        `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
        `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


        Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
        size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
        query with filters and retry).


        Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
        conditions: `502` means a command dependency could not accept the request, `503` means a required service
        (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no
        spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
      title: V1SessionsUuidPlaybackPausePostResponsesContentApplicationJsonSchemaCode
    PausePlaybackRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackPausePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: PausePlaybackRequestBadRequestError
    PausePlaybackRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackPausePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: PausePlaybackRequestUnauthorizedError
    PausePlaybackRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackPausePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: PausePlaybackRequestNotFoundError
    PausePlaybackRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackPausePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: PausePlaybackRequestConflictError
    PausePlaybackRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackPausePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: PausePlaybackRequestContentTooLargeError
    PausePlaybackRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackPausePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: PausePlaybackRequestUnsupportedMediaTypeError
    PausePlaybackRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackPausePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: PausePlaybackRequestUnprocessableEntityError
    PausePlaybackRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackPausePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - retry_after
        - success
      title: PausePlaybackRequestTooManyRequestsError
    PausePlaybackRequestInternalServerError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackPausePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: PausePlaybackRequestInternalServerError
    PausePlaybackRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackPausePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: PausePlaybackRequestServiceUnavailableError
    PlaybackStartAudioPlaybackRequest0:
      type: object
      properties:
        offset_ms:
          type: integer
          description: |-
            Optional starting offset in milliseconds. It is valid only
            with one finite source.
        operation_uuid:
          type: string
          format: uuid
          description: >-
            Optional caller-supplied per-command correlation id, a bare lowercase RFC-4122 v4 UUID (no prefix). Echoed
            back as `operation_uuid` in the 202 ack. A later lifecycle webhook carries it only when the gateway can
            unambiguously associate that event with this command; the field is correlation, not proof of causation. When
            omitted, the gateway mints one. Not an idempotency key — request deduplication is the `Idempotency-Key`
            header. Invalid input (not a v4 UUID) is rejected with `400 invalid_request`.
        type:
          type: string
          enum:
            - files
          description: Selects finite-file playback.
        urls:
          type: array
          items:
            type: string
            format: uri
          description: |-
            HTTP/HTTPS URLs of audio files to play sequentially. With two
            or more URLs, playback is one continuous playlist, but seeking
            across playlist file boundaries is undefined.
      required:
        - type
        - urls
      title: PlaybackStartAudioPlaybackRequest0
    PlaybackStartAudioPlaybackRequest1:
      type: object
      properties:
        operation_uuid:
          type: string
          format: uuid
          description: >-
            Optional caller-supplied per-command correlation id, a bare lowercase RFC-4122 v4 UUID (no prefix). Echoed
            back as `operation_uuid` in the 202 ack. A later lifecycle webhook carries it only when the gateway can
            unambiguously associate that event with this command; the field is correlation, not proof of causation. When
            omitted, the gateway mints one. Not an idempotency key — request deduplication is the `Idempotency-Key`
            header. Invalid input (not a v4 UUID) is rejected with `400 invalid_request`.
        type:
          type: string
          enum:
            - stream
          description: Selects live-stream playback.
        url:
          type: string
          format: uri
          description: The single live HTTP/HTTPS stream to play.
      required:
        - type
        - url
      title: PlaybackStartAudioPlaybackRequest1
    PlaybackStartAudioPlaybackRequest2:
      type: object
      properties:
        operation_uuid:
          type: string
          format: uuid
          description: >-
            Optional caller-supplied per-command correlation id, a bare lowercase RFC-4122 v4 UUID (no prefix). Echoed
            back as `operation_uuid` in the 202 ack. A later lifecycle webhook carries it only when the gateway can
            unambiguously associate that event with this command; the field is correlation, not proof of causation. When
            omitted, the gateway mints one. Not an idempotency key — request deduplication is the `Idempotency-Key`
            header. Invalid input (not a v4 UUID) is rejected with `400 invalid_request`.
        type:
          type: string
          enum:
            - silence
          description: Selects indefinite silence playback until replaced or stopped.
      required:
        - type
      title: PlaybackStartAudioPlaybackRequest2
    Playback_startAudioPlayback_Request:
      oneOf:
        - $ref: '#/components/schemas/PlaybackStartAudioPlaybackRequest0'
        - $ref: '#/components/schemas/PlaybackStartAudioPlaybackRequest1'
        - $ref: '#/components/schemas/PlaybackStartAudioPlaybackRequest2'
      description: >-
        Audio source. `files` uses `urls`, `stream` uses one `url`, and `silence` has no source URL. The shapes cannot
        be mixed.
      title: Playback_startAudioPlayback_Request
    V1SessionsUuidPlaybackPlayPostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
        - internal
      description: >-
        Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
        handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
        `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
        `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
        `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


        Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
        size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
        query with filters and retry).


        Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
        conditions: `502` means a command dependency could not accept the request, `503` means a required service
        (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no
        spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
      title: V1SessionsUuidPlaybackPlayPostResponsesContentApplicationJsonSchemaCode
    StartAudioPlaybackRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackPlayPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StartAudioPlaybackRequestBadRequestError
    StartAudioPlaybackRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackPlayPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StartAudioPlaybackRequestUnauthorizedError
    StartAudioPlaybackRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackPlayPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StartAudioPlaybackRequestNotFoundError
    StartAudioPlaybackRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackPlayPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StartAudioPlaybackRequestConflictError
    StartAudioPlaybackRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackPlayPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StartAudioPlaybackRequestContentTooLargeError
    StartAudioPlaybackRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackPlayPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StartAudioPlaybackRequestUnsupportedMediaTypeError
    StartAudioPlaybackRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackPlayPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StartAudioPlaybackRequestUnprocessableEntityError
    StartAudioPlaybackRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackPlayPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - retry_after
        - success
      title: StartAudioPlaybackRequestTooManyRequestsError
    StartAudioPlaybackRequestInternalServerError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackPlayPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StartAudioPlaybackRequestInternalServerError
    StartAudioPlaybackRequestBadGatewayError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackPlayPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StartAudioPlaybackRequestBadGatewayError
    StartAudioPlaybackRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackPlayPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StartAudioPlaybackRequestServiceUnavailableError
    V1SessionsUuidPlaybackRestartPostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
        - internal
      description: >-
        Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
        handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
        `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
        `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
        `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


        Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
        size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
        query with filters and retry).


        Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
        conditions: `502` means a command dependency could not accept the request, `503` means a required service
        (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no
        spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
      title: V1SessionsUuidPlaybackRestartPostResponsesContentApplicationJsonSchemaCode
    RestartPlaybackRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackRestartPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: RestartPlaybackRequestBadRequestError
    RestartPlaybackRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackRestartPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: RestartPlaybackRequestUnauthorizedError
    RestartPlaybackRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackRestartPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: RestartPlaybackRequestNotFoundError
    RestartPlaybackRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackRestartPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: RestartPlaybackRequestConflictError
    RestartPlaybackRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackRestartPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: RestartPlaybackRequestContentTooLargeError
    RestartPlaybackRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackRestartPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: RestartPlaybackRequestUnsupportedMediaTypeError
    RestartPlaybackRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackRestartPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: RestartPlaybackRequestUnprocessableEntityError
    RestartPlaybackRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackRestartPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - retry_after
        - success
      title: RestartPlaybackRequestTooManyRequestsError
    RestartPlaybackRequestInternalServerError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackRestartPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: RestartPlaybackRequestInternalServerError
    RestartPlaybackRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackRestartPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: RestartPlaybackRequestServiceUnavailableError
    V1SessionsUuidPlaybackResumePostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
        - internal
      description: >-
        Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
        handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
        `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
        `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
        `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


        Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
        size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
        query with filters and retry).


        Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
        conditions: `502` means a command dependency could not accept the request, `503` means a required service
        (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no
        spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
      title: V1SessionsUuidPlaybackResumePostResponsesContentApplicationJsonSchemaCode
    ResumePlaybackRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackResumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: ResumePlaybackRequestBadRequestError
    ResumePlaybackRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackResumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: ResumePlaybackRequestUnauthorizedError
    ResumePlaybackRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackResumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: ResumePlaybackRequestNotFoundError
    ResumePlaybackRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackResumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: ResumePlaybackRequestConflictError
    ResumePlaybackRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackResumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: ResumePlaybackRequestContentTooLargeError
    ResumePlaybackRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackResumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: ResumePlaybackRequestUnsupportedMediaTypeError
    ResumePlaybackRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackResumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: ResumePlaybackRequestUnprocessableEntityError
    ResumePlaybackRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackResumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - retry_after
        - success
      title: ResumePlaybackRequestTooManyRequestsError
    ResumePlaybackRequestInternalServerError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackResumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: ResumePlaybackRequestInternalServerError
    ResumePlaybackRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackResumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: ResumePlaybackRequestServiceUnavailableError
    V1SessionsUuidPlaybackSeekPostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
        - internal
      description: >-
        Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
        handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
        `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
        `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
        `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


        Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
        size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
        query with filters and retry).


        Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
        conditions: `502` means a command dependency could not accept the request, `503` means a required service
        (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no
        spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
      title: V1SessionsUuidPlaybackSeekPostResponsesContentApplicationJsonSchemaCode
    SeekWithinPlaybackRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackSeekPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: SeekWithinPlaybackRequestBadRequestError
    SeekWithinPlaybackRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackSeekPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: SeekWithinPlaybackRequestUnauthorizedError
    SeekWithinPlaybackRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackSeekPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: SeekWithinPlaybackRequestNotFoundError
    SeekWithinPlaybackRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackSeekPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: SeekWithinPlaybackRequestConflictError
    SeekWithinPlaybackRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackSeekPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: SeekWithinPlaybackRequestContentTooLargeError
    SeekWithinPlaybackRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackSeekPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: SeekWithinPlaybackRequestUnsupportedMediaTypeError
    SeekWithinPlaybackRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackSeekPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: SeekWithinPlaybackRequestUnprocessableEntityError
    SeekWithinPlaybackRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackSeekPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - retry_after
        - success
      title: SeekWithinPlaybackRequestTooManyRequestsError
    SeekWithinPlaybackRequestInternalServerError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackSeekPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: SeekWithinPlaybackRequestInternalServerError
    SeekWithinPlaybackRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackSeekPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: SeekWithinPlaybackRequestServiceUnavailableError
    V1SessionsUuidPlaybackStopPostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
        - internal
      description: >-
        Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
        handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
        `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
        `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
        `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


        Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
        size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
        query with filters and retry).


        Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
        conditions: `502` means a command dependency could not accept the request, `503` means a required service
        (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no
        spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
      title: V1SessionsUuidPlaybackStopPostResponsesContentApplicationJsonSchemaCode
    StopPlaybackRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StopPlaybackRequestBadRequestError
    StopPlaybackRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StopPlaybackRequestUnauthorizedError
    StopPlaybackRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StopPlaybackRequestNotFoundError
    StopPlaybackRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StopPlaybackRequestConflictError
    StopPlaybackRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StopPlaybackRequestContentTooLargeError
    StopPlaybackRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StopPlaybackRequestUnsupportedMediaTypeError
    StopPlaybackRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StopPlaybackRequestUnprocessableEntityError
    StopPlaybackRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - retry_after
        - success
      title: StopPlaybackRequestTooManyRequestsError
    StopPlaybackRequestInternalServerError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StopPlaybackRequestInternalServerError
    StopPlaybackRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: StopPlaybackRequestServiceUnavailableError
    V1SessionsUuidPlayAndGetDigitsPostRequestBodyContentApplicationJsonSchemaTerminatorsItems:
      type: string
      enum:
        - '#'
        - '*'
      title: V1SessionsUuidPlayAndGetDigitsPostRequestBodyContentApplicationJsonSchemaTerminatorsItems
    V1SessionsUuidPlayAndGetDigitsPostRequestBodyContentApplicationJsonSchemaValidation:
      type: object
      properties:
        regex:
          type: string
          description: >-
            RE2 regular expression the collected digits must match (no whitespace, <=256 chars). On match-and-fail,
            status is `invalid`.
      description: Optional input validation.
      title: V1SessionsUuidPlayAndGetDigitsPostRequestBodyContentApplicationJsonSchemaValidation
    V1SessionsUuidPlayAndGetDigitsPostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
        - internal
      description: >-
        Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
        handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
        `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
        `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
        `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


        Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
        size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
        query with filters and retry).


        Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
        conditions: `502` means a command dependency could not accept the request, `503` means a required service
        (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no
        spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
      title: V1SessionsUuidPlayAndGetDigitsPostResponsesContentApplicationJsonSchemaCode
    PlayPromptAndCollectDTMFDigitsRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlayAndGetDigitsPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: PlayPromptAndCollectDTMFDigitsRequestBadRequestError
    PlayPromptAndCollectDTMFDigitsRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlayAndGetDigitsPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: PlayPromptAndCollectDTMFDigitsRequestUnauthorizedError
    PlayPromptAndCollectDTMFDigitsRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlayAndGetDigitsPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: PlayPromptAndCollectDTMFDigitsRequestNotFoundError
    PlayPromptAndCollectDTMFDigitsRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlayAndGetDigitsPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: PlayPromptAndCollectDTMFDigitsRequestConflictError
    PlayPromptAndCollectDTMFDigitsRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlayAndGetDigitsPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: PlayPromptAndCollectDTMFDigitsRequestContentTooLargeError
    PlayPromptAndCollectDTMFDigitsRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlayAndGetDigitsPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: PlayPromptAndCollectDTMFDigitsRequestUnsupportedMediaTypeError
    PlayPromptAndCollectDTMFDigitsRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlayAndGetDigitsPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: PlayPromptAndCollectDTMFDigitsRequestUnprocessableEntityError
    PlayPromptAndCollectDTMFDigitsRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlayAndGetDigitsPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - retry_after
        - success
      title: PlayPromptAndCollectDTMFDigitsRequestTooManyRequestsError
    PlayPromptAndCollectDTMFDigitsRequestInternalServerError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlayAndGetDigitsPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: PlayPromptAndCollectDTMFDigitsRequestInternalServerError
    PlayPromptAndCollectDTMFDigitsRequestBadGatewayError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlayAndGetDigitsPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: PlayPromptAndCollectDTMFDigitsRequestBadGatewayError
    PlayPromptAndCollectDTMFDigitsRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlayAndGetDigitsPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: PlayPromptAndCollectDTMFDigitsRequestServiceUnavailableError
    V1SessionsUuidPlayAndGetDigitsDeleteResponsesContentApplicationJsonSchemaStatus:
      type: string
      enum:
        - cancelling
      title: V1SessionsUuidPlayAndGetDigitsDeleteResponsesContentApplicationJsonSchemaStatus
    Collect keypad input_cancelPlayPromptAndCollectDTMFDigits_Response_202:
      type: object
      properties:
        operation_uuid:
          type: string
          format: uuid
        status:
          $ref: '#/components/schemas/V1SessionsUuidPlayAndGetDigitsDeleteResponsesContentApplicationJsonSchemaStatus'
      required:
        - operation_uuid
        - status
      description: >-
        An accepted asynchronous command. Store `operation_uuid` and use it to correlate later lifecycle events; an
        event that carries the same field is a correlation link, not an embedded Operation object.
      title: Collect keypad input_cancelPlayPromptAndCollectDTMFDigits_Response_202
    V1SessionsUuidPlayAndGetDigitsDeleteResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
        - internal
      description: >-
        Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
        handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
        `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
        `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
        `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


        Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
        size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
        query with filters and retry).


        Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
        conditions: `502` means a command dependency could not accept the request, `503` means a required service
        (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no
        spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
      title: V1SessionsUuidPlayAndGetDigitsDeleteResponsesContentApplicationJsonSchemaCode
    CancelPlayPromptAndCollectDTMFDigitsRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlayAndGetDigitsDeleteResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: CancelPlayPromptAndCollectDTMFDigitsRequestBadRequestError
    CancelPlayPromptAndCollectDTMFDigitsRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlayAndGetDigitsDeleteResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: CancelPlayPromptAndCollectDTMFDigitsRequestUnauthorizedError
    CancelPlayPromptAndCollectDTMFDigitsRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlayAndGetDigitsDeleteResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: CancelPlayPromptAndCollectDTMFDigitsRequestNotFoundError
    CancelPlayPromptAndCollectDTMFDigitsRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlayAndGetDigitsDeleteResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - retry_after
        - success
      title: CancelPlayPromptAndCollectDTMFDigitsRequestTooManyRequestsError
    CancelPlayPromptAndCollectDTMFDigitsRequestInternalServerError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlayAndGetDigitsDeleteResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: CancelPlayPromptAndCollectDTMFDigitsRequestInternalServerError
    AppWebhookConfigResponse:
      type: object
      properties:
        webhook_url:
          type:
            - string
            - 'null'
          description: Webhook delivery URL, or null when webhook delivery is disabled.
      required:
        - webhook_url
      title: AppWebhookConfigResponse
    ApiV1AppWebhookGetResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
        - internal
      description: >-
        Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
        handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
        `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
        `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
        `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


        Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
        size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
        query with filters and retry).


        Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
        conditions: `502` means a command dependency could not accept the request, `503` means a required service
        (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no
        spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
      title: ApiV1AppWebhookGetResponsesContentApplicationJsonSchemaCode
    GetWebhookConfigurationRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1AppWebhookGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: GetWebhookConfigurationRequestUnauthorizedError
    GetWebhookConfigurationRequestInternalServerError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1AppWebhookGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: GetWebhookConfigurationRequestInternalServerError
    GetWebhookConfigurationRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1AppWebhookGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: GetWebhookConfigurationRequestServiceUnavailableError
    AppWebhookConfigRequest:
      type: object
      properties:
        webhook_url:
          type:
            - string
            - 'null'
          description: >-
            Webhook delivery URL. Set to null or an empty string to disable webhook delivery. HTTPS is required unless
            the operator has explicitly enabled HTTP webhooks.
      required:
        - webhook_url
      title: AppWebhookConfigRequest
    ApiV1AppWebhookPutResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
        - internal
      description: >-
        Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
        handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
        `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
        `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
        `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


        Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
        size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
        query with filters and retry).


        Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
        conditions: `502` means a command dependency could not accept the request, `503` means a required service
        (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no
        spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
      title: ApiV1AppWebhookPutResponsesContentApplicationJsonSchemaCode
    UpdateWebhookConfigurationRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1AppWebhookPutResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: UpdateWebhookConfigurationRequestBadRequestError
    UpdateWebhookConfigurationRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1AppWebhookPutResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: UpdateWebhookConfigurationRequestUnauthorizedError
    UpdateWebhookConfigurationRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1AppWebhookPutResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: UpdateWebhookConfigurationRequestContentTooLargeError
    UpdateWebhookConfigurationRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1AppWebhookPutResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: UpdateWebhookConfigurationRequestUnsupportedMediaTypeError
    UpdateWebhookConfigurationRequestInternalServerError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1AppWebhookPutResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: UpdateWebhookConfigurationRequestInternalServerError
    UpdateWebhookConfigurationRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1AppWebhookPutResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic
            handling. New codes are only added with a documented API change. Maps to the HTTP status as follows:
            `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401),
            `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409),
            `rate_limited` (429), `unavailable` (502/503/529), `internal` (500).


            Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its
            size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the
            query with filters and retry).


            Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry
            conditions: `502` means a command dependency could not accept the request, `503` means a required service
            (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with
            no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them.
        error:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
        retry_after:
          type: integer
          description: >-
            Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills
            by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header.
        success:
          type: boolean
      required:
        - code
        - error
        - success
      title: UpdateWebhookConfigurationRequestServiceUnavailableError
    HealthGetResponsesContentApplicationJsonSchemaRedis:
      type: string
      enum:
        - ok
        - error
      title: HealthGetResponsesContentApplicationJsonSchemaRedis
    HealthGetResponsesContentApplicationJsonSchemaRouting:
      type: string
      enum:
        - ok
        - stale
      title: HealthGetResponsesContentApplicationJsonSchemaRouting
    HealthGetResponsesContentApplicationJsonSchemaStatus:
      type: string
      enum:
        - degraded
      title: HealthGetResponsesContentApplicationJsonSchemaStatus
    Health_check_Response_200:
      type: object
      properties:
        event_consumer_count:
          type: integer
        goroutines:
          type: integer
        redis:
          $ref: '#/components/schemas/HealthGetResponsesContentApplicationJsonSchemaRedis'
        routing:
          $ref: '#/components/schemas/HealthGetResponsesContentApplicationJsonSchemaRouting'
        status:
          $ref: '#/components/schemas/HealthGetResponsesContentApplicationJsonSchemaStatus'
      required:
        - event_consumer_count
        - goroutines
        - redis
        - routing
        - status
      title: Health_check_Response_200
    HealthCheckRequestServiceUnavailableError:
      type: object
      properties:
        event_consumer_count:
          type: integer
        goroutines:
          type: integer
        redis:
          $ref: '#/components/schemas/HealthGetResponsesContentApplicationJsonSchemaRedis'
        routing:
          $ref: '#/components/schemas/HealthGetResponsesContentApplicationJsonSchemaRouting'
        status:
          $ref: '#/components/schemas/HealthGetResponsesContentApplicationJsonSchemaStatus'
      required:
        - event_consumer_count
        - goroutines
        - redis
        - routing
        - status
      title: HealthCheckRequestServiceUnavailableError
    LivezGetResponsesContentApplicationJsonSchemaStatus:
      type: string
      enum:
        - ok
      title: LivezGetResponsesContentApplicationJsonSchemaStatus
    Health_livenessCheck_Response_200:
      type: object
      properties:
        status:
          $ref: '#/components/schemas/LivezGetResponsesContentApplicationJsonSchemaStatus'
      required:
        - status
      title: Health_livenessCheck_Response_200
  securitySchemes:
    bearerAppAuth:
      type: http
      scheme: bearer
      description: >-
        Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>`. See
        [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for details.
