openapi: 3.1.0
info:
  title: API Overview
  version: 1.0.0
paths:
  /.well-known/webhook-public-keys:
    get:
      operationId: getWebhookPublicKeys
      summary: Webhook signature public keys
      description: |-
        Return the Ed25519 public keys used to verify `v1a` entries in
        `Webhook-Signature`. This endpoint does not require authentication because
        it returns only public keys, integer key IDs (`akid`), and an algorithm name.
        It does not return secrets or application data.

        Every webhook delivery carries `Webhook-Id`, `Webhook-Timestamp`, and
        `Webhook-Signature: v1a,<base64>`. Verify at least one signature against
        the complete active key set over the exact signing input
        `<webhook-id>.<webhook-timestamp>.<raw_body>`. During rotation, deliveries
        carry a space-delimited signature for each active private key. See the
        Webhook Signatures guide.
      tags:
        - webhooks
      responses:
        '200':
          description: |
            Current set of webhook signature public keys.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WebhookPublicKeysResponse'
  /v1/sessions:
    get:
      operationId: listSessions
      summary: List sessions
      description: |-
        List the app's [sessions](/api/sessions), ordered from newest to
        oldest by `created_at`. The optional filters are combined, so a session
        must match every supplied filter.

        The endpoint does not use pagination. It returns all matching sessions when
        `limit` is omitted. When `limit` is set, it caps the number of filtered
        sessions returned, and `has_more` indicates whether additional matches
        exist.
      tags:
        - sessionsCalls
      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
            minimum: 1
        - 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
            pattern: ^\+[1-9]\d{1,14}$
        - 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
            pattern: ^\+[1-9]\d{1,14}$
        - 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>` using any active key in the app's
            collection. 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. Request-validation
            messages identify the failing parameter in `The "<path>" ...` form.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400 invalid_authorization_header`.
          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 for the applicable per-command, per-room, or per-app scope. The `Retry-After` response
            header gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ListSessionsRequestTooManyRequestsError'
        '500':
          description: >-
            An unexpected platform failure. Quote `support_id` to support; the technical cause and vendor event
            identifier are never exposed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
  /v1/sessions/{uuid}:
    get:
      operationId: getSessionDetails
      summary: Get session details
      description: Get details for a [session](/api/sessions) owned by your app.
      tags:
        - sessionsCalls
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) identifier.'
          required: true
          schema:
            type: string
        - name: uuid
          in: path
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. 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` or malformed Bearer credentials return `invalid_authorization_header`; invalid
            request parameters return `invalid_request`. A syntactically valid credential with an invalid API key
            returns `401 unauthorized` 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 invalid_authorization_header`.
          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: >-
            An unexpected platform failure. Quote `support_id` to support; the technical cause and vendor event
            identifier are never exposed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
    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.


        **Tip:** This endpoint disconnects a Session whether or not its call has been answered. Use [Reject an incoming
        call](/api/sessions/reject) for an unanswered inbound call or [Cancel an unanswered outgoing
        call](/api/sessions/cancel) for an unanswered outbound call; those endpoints return `409 Conflict` after the
        call is answered.


        **Triggered webhooks:** `session.ended` (deferred)


        See [Session lifecycle events](/api/sessions#lifecycle-events) for complete payload schemas and examples.
      tags:
        - sessionsCalls
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) identifier.'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. See [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for
            details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional key for safely retrying mutating requests. See
            [Idempotency](https://voice-platform.docs.buildwithfern.com/idempotency) for details.
          required: false
          schema:
            type: string
            pattern: ^[a-zA-Z0-9._-]+$
            maxLength: 128
        - name: Operation-Id
          in: header
          description: >-
            optional client-supplied lowercase RFC-4122 v4 UUID returned as operation_uuid; platform generates one when
            omitted; correlation metadata distinct from Idempotency-Key.
          required: false
          schema:
            type: string
            format: uuid
            pattern: ^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
      responses:
        '202':
          description: Command accepted for async execution
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AsyncCommandResponse'
        '400':
          description: >-
            Missing `Authorization` or malformed Bearer credentials return `invalid_authorization_header`; invalid
            request parameters return `invalid_request`. A syntactically valid credential with an invalid API key
            returns `401 unauthorized` 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 invalid_authorization_header`.
          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: >-
            Send JSON request bodies with `Content-Type: application/json`. The API rejects an explicitly supplied
            malformed or unsupported media type.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DeleteSessionRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different method, path, query, content type, body, or
            `Operation-Id`. A key maps to one request; use a new key. See the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DeleteSessionRequestUnprocessableEntityError'
        '500':
          description: >-
            An unexpected platform failure. Quote `support_id` to support; the technical cause and vendor event
            identifier are never exposed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
        '503':
          description: >-
            When an `Idempotency-Key` was supplied, the idempotency store is unavailable and the request was NOT
            processed; retry with the same key. An operation can document another `503` condition with different
            execution and retry guidance; follow the operation description and the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DeleteSessionRequestServiceUnavailableError'
  /v1/sessions:dial:
    post:
      operationId: createDial
      summary: Originate outbound call
      description: |-
        Start an outbound call and return its new `session_uuid` after the
        request is admitted. A `202 Accepted` response confirms only admission; it
        does not confirm that the destination rang or answered. Call progress and
        completion are reported through webhooks.

        **Triggered webhooks:**
        `session.ringing_started`, `session.answered`, and `session.ended`. The optional
        `session.early_media_started` webhook does not indicate an answer.

        See [Session lifecycle events](/api/sessions#lifecycle-events) for complete payload schemas and examples.
      tags:
        - sessionsCalls
      parameters:
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. See [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for
            details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional key for safely retrying mutating requests. See
            [Idempotency](https://voice-platform.docs.buildwithfern.com/idempotency) for details.
          required: false
          schema:
            type: string
            pattern: ^[a-zA-Z0-9._-]+$
            maxLength: 128
      responses:
        '202':
          description: Dial accepted
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Sessions & Calls_createDial_Response_202'
        '400':
          description: >-
            Missing or malformed `Authorization`, invalid JSON, or a runtime phone-policy rejection. Invalid API keys
            return `401`.
          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 invalid_authorization_header`.
          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: >-
            Send JSON request bodies with `Content-Type: application/json`. The API rejects an explicitly supplied
            malformed or unsupported media type.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateDialRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            Schema failures and idempotency-key reuse return `code: invalid_request` and a single human-readable
            `message`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateDialRequestUnprocessableEntityError'
        '500':
          description: >-
            An unexpected platform failure. Quote `support_id` to support; the technical cause and vendor event
            identifier are never exposed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
        '503':
          description: |-
            The idempotency store is unavailable, or new-session admission is
            temporarily closed. If the response includes `Retry-After`, its message
            says `See Retry-After header`; wait that many seconds. Otherwise, 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
                  pattern: ^\+[1-9]\d{1,14}$
                  description: |-
                    Caller ID to present, in the same E.164 format with leading `+` as `to` (e.g. `+972500000000`).
                    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 platform 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
                  minimum: 1
                  maximum: 14400
                  description: Maximum total call duration in seconds. A typical value is 3600.
                ring_timeout_sec:
                  type: integer
                  minimum: 1
                  maximum: 300
                  description: |-
                    Pre-answer ring timeout in seconds, measured from when dialing begins
                    (the moment the request returns 202 Accepted), 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
                  pattern: ^\+[1-9]\d{1,14}$
                  description: |-
                    Destination number in international E.164 format with leading `+` (e.g. `+972500000000`).
                    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/{uuid}/answer:
    post:
      operationId: answerACall
      summary: Answer a call
      description: |-
        Answer an incoming call. A `202 Accepted` response
        confirms only that the command was admitted; it does not confirm that the
        call was answered. The `session.answered` webhook confirms completion. If
        the call ends before it is answered, `session.ended` reports `answered: false`.

        **Triggered webhooks:** `session.answered`

        See [Session lifecycle events](/api/sessions#lifecycle-events) for complete payload schemas and examples.
      tags:
        - sessionsCalls
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) identifier.'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. See [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for
            details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional key for safely retrying mutating requests. See
            [Idempotency](https://voice-platform.docs.buildwithfern.com/idempotency) for details.
          required: false
          schema:
            type: string
            pattern: ^[a-zA-Z0-9._-]+$
            maxLength: 128
        - name: Operation-Id
          in: header
          description: >-
            optional client-supplied lowercase RFC-4122 v4 UUID returned as operation_uuid; platform generates one when
            omitted; correlation metadata distinct from Idempotency-Key.
          required: false
          schema:
            type: string
            format: uuid
            pattern: ^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
      responses:
        '202':
          description: Command accepted for async execution
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AsyncCommandResponse'
        '400':
          description: >-
            Missing `Authorization` or malformed Bearer credentials return `invalid_authorization_header`; invalid
            request parameters return `invalid_request`. A syntactically valid credential with an invalid API key
            returns `401 unauthorized` 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 invalid_authorization_header`.
          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: >-
            Send JSON request bodies with `Content-Type: application/json`. The API rejects an explicitly supplied
            malformed or unsupported media type.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AnswerACallRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different method, path, query, content type, body, or
            `Operation-Id`. A key maps to one request; use a new key. See the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AnswerACallRequestUnprocessableEntityError'
        '500':
          description: >-
            An unexpected platform failure. Quote `support_id` to support; the technical cause and vendor event
            identifier are never exposed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
        '503':
          description: >-
            When an `Idempotency-Key` was supplied, the idempotency store is unavailable and the request was NOT
            processed; retry with the same key. An operation can document another `503` condition with different
            execution and retry guidance; follow the operation description and the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AnswerACallRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties: {}
  /v1/sessions/{uuid}/reject:
    post:
      operationId: rejectIncomingCall
      summary: Reject an incoming call
      description: >-
        Reject an inbound phone session before it is answered. The session must currently be ringing or in early media;
        otherwise the request returns `409 Conflict`.


        Use the `reason` field to select the caller-facing outcome, such as busy, rejected, number not found.


        A `202 Accepted` response means the rejection request was accepted for processing; it does not mean the session
        has ended. Wait for the deferred `session.ended` webhook to confirm termination.


        **Tip:** Use this endpoint only for an unanswered inbound call. After the call is answered, this endpoint
        returns `409 Conflict`; use [Delete session](/api/sessions/delete) to disconnect a Session whether or not its
        call has been answered.


        **Triggered webhooks:** `session.ended` (deferred)
      tags:
        - sessionsCalls
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) identifier.'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. See [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for
            details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional key for safely retrying mutating requests. See
            [Idempotency](https://voice-platform.docs.buildwithfern.com/idempotency) for details.
          required: false
          schema:
            type: string
            pattern: ^[a-zA-Z0-9._-]+$
            maxLength: 128
        - name: Operation-Id
          in: header
          description: >-
            optional client-supplied lowercase RFC-4122 v4 UUID returned as operation_uuid; platform generates one when
            omitted; correlation metadata distinct from Idempotency-Key.
          required: false
          schema:
            type: string
            format: uuid
            pattern: ^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
      responses:
        '202':
          description: Command accepted for async execution
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AsyncCommandResponse'
        '400':
          description: >-
            Missing `Authorization` or malformed Bearer credentials return `invalid_authorization_header`; invalid
            request parameters return `invalid_request`. A syntactically valid credential with an invalid API key
            returns `401 unauthorized` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RejectIncomingCallRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400 invalid_authorization_header`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RejectIncomingCallRequestUnauthorizedError'
        '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/RejectIncomingCallRequestNotFoundError'
        '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/RejectIncomingCallRequestConflictError'
        '413':
          description: Request body exceeds the endpoint's size limit.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RejectIncomingCallRequestContentTooLargeError'
        '415':
          description: >-
            Send JSON request bodies with `Content-Type: application/json`. The API rejects an explicitly supplied
            malformed or unsupported media type.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RejectIncomingCallRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different method, path, query, content type, body, or
            `Operation-Id`. A key maps to one request; use a new key. See the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RejectIncomingCallRequestUnprocessableEntityError'
        '500':
          description: >-
            An unexpected platform failure. Quote `support_id` to support; the technical cause and vendor event
            identifier are never exposed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
        '503':
          description: >-
            When an `Idempotency-Key` was supplied, the idempotency store is unavailable and the request was NOT
            processed; retry with the same key. An operation can document another `503` condition with different
            execution and retry guidance; follow the operation description and the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RejectIncomingCallRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties:
                reason:
                  $ref: '#/components/schemas/V1SessionsUuidRejectPostRequestBodyContentApplicationJsonSchemaReason'
                  description: >-
                    Public hangup cause for the resulting `session.ended` event: `number_not_found`, `invalid_number`,
                    `timeout`, `busy`, or `rejected`.
              required:
                - reason
  /v1/sessions/{uuid}/cancel:
    post:
      operationId: cancelOutgoingCall
      summary: Cancel an unanswered outgoing call
      description: >-
        Stop an outbound phone call before the callee answers. The request returns `409 Conflict` if the session is
        already answered or cannot be cancelled. A `202 Accepted` response means the cancellation request was queued.
        The existing deferred `session.ended` webhook confirms termination. No cancellation-specific webhook is emitted.


        **Tip:** Use this endpoint only for an unanswered outbound call. After the call is answered, this endpoint
        returns `409 Conflict`; use [Delete session](/api/sessions/delete) to disconnect a Session whether or not its
        call has been answered.


        **Triggered webhooks:** `session.ended` (deferred)
      tags:
        - sessionsCalls
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) identifier.'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. See [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for
            details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional key for safely retrying mutating requests. See
            [Idempotency](https://voice-platform.docs.buildwithfern.com/idempotency) for details.
          required: false
          schema:
            type: string
            pattern: ^[a-zA-Z0-9._-]+$
            maxLength: 128
        - name: Operation-Id
          in: header
          description: >-
            optional client-supplied lowercase RFC-4122 v4 UUID returned as operation_uuid; platform generates one when
            omitted; correlation metadata distinct from Idempotency-Key.
          required: false
          schema:
            type: string
            format: uuid
            pattern: ^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
      responses:
        '202':
          description: Command accepted for async execution
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AsyncCommandResponse'
        '400':
          description: >-
            Missing `Authorization` or malformed Bearer credentials return `invalid_authorization_header`; invalid
            request parameters return `invalid_request`. A syntactically valid credential with an invalid API key
            returns `401 unauthorized` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CancelOutgoingCallRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400 invalid_authorization_header`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CancelOutgoingCallRequestUnauthorizedError'
        '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/CancelOutgoingCallRequestNotFoundError'
        '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/CancelOutgoingCallRequestConflictError'
        '413':
          description: Request body exceeds the endpoint's size limit.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CancelOutgoingCallRequestContentTooLargeError'
        '415':
          description: >-
            Send JSON request bodies with `Content-Type: application/json`. The API rejects an explicitly supplied
            malformed or unsupported media type.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CancelOutgoingCallRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different method, path, query, content type, body, or
            `Operation-Id`. A key maps to one request; use a new key. See the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CancelOutgoingCallRequestUnprocessableEntityError'
        '500':
          description: >-
            An unexpected platform failure. Quote `support_id` to support; the technical cause and vendor event
            identifier are never exposed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
        '503':
          description: >-
            When an `Idempotency-Key` was supplied, the idempotency store is unavailable and the request was NOT
            processed; retry with the same key. An operation can document another `503` condition with different
            execution and retry guidance; follow the operation description and the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CancelOutgoingCallRequestServiceUnavailableError'
  /v1/sessions:connectWebsocket:
    post:
      operationId: createSession
      summary: Create a WebSocket session
      description: |-
        Create a [WebSocket session](/api/sessions) with no phone leg.
        The session acts as an independent participant and exchanges audio with the
        configured external WebSocket server. Only `type: "websocket"` is supported.

        The session starts in the `connecting` state. After the WebSocket connection
        is established, the session advances to `answered`. Its lifetime is bound to
        that connection. If the server disconnects or does not connect before the
        timeout, the session ends and a `session.ended` webhook is emitted.

        You can [add or remove the session from rooms](/api/room-members) and use all
        supported session commands. Closing the WebSocket ends the session. This
        endpoint creates a new session.

        **Triggered webhooks:** `websocket.connected`, `websocket.disconnected`, `websocket.failed`,
        `websocket.audio_playback_completed`, `session.ended`

        See [WebSocket lifecycle events](/api/web-socket#lifecycle-events) for complete payload schemas and examples.

        See [Session lifecycle events](/api/sessions#lifecycle-events) for complete payload schemas and examples.
      tags:
        - webSocket
      parameters:
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. See [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for
            details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional key for safely retrying mutating requests. See
            [Idempotency](https://voice-platform.docs.buildwithfern.com/idempotency) for details.
          required: false
          schema:
            type: string
            pattern: ^[a-zA-Z0-9._-]+$
            maxLength: 128
      responses:
        '201':
          description: Session created. Born in the `connecting` state.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Session'
        '400':
          description: >-
            Missing `Authorization` or malformed Bearer credentials return `invalid_authorization_header`; invalid
            request parameters return `invalid_request`. A syntactically valid credential with an invalid API key
            returns `401 unauthorized` 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 invalid_authorization_header`.
          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: >-
            Send JSON request bodies with `Content-Type: application/json`. The API rejects an explicitly supplied
            malformed or unsupported media type.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateSessionRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different method, path, query, content type, body, or
            `Operation-Id`. A key maps to one request; use a new key. See the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateSessionRequestUnprocessableEntityError'
        '500':
          description: >-
            An unexpected platform failure. Quote `support_id` to support; the technical cause and vendor event
            identifier are never exposed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
        '503':
          description: |-
            The idempotency store is unavailable, or new-session admission is
            temporarily closed. If the response includes `Retry-After`, its message
            says `See Retry-After header`; wait that many seconds. Otherwise, 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/WebSocketConfig'
              required:
                - type
                - websocket
  /api/v1/rooms:
    get:
      operationId: listRooms
      summary: List rooms
      description: |-
        List [rooms](/api/rooms) owned by the authenticated app. The
        response never includes rooms owned by another app. Results are sorted
        newest first by `created_at`.

        This endpoint uses an optional `limit`, not cursor pagination. Omit `limit`
        to return every room owned by the app. If `limit` truncates the result,
        `has_more` is `true`. The system result ceiling is evaluated before
        `limit`, so `limit` cannot prevent a `413` response when the full result
        set exceeds that ceiling.
      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
            minimum: 1
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. 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 invalid_authorization_header`.
          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 for the applicable per-command, per-room, or per-app scope. The `Retry-After` response
            header gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ListRoomsRequestTooManyRequestsError'
        '500':
          description: >-
            An unexpected platform failure. Quote `support_id` to support; the technical cause and vendor event
            identifier are never exposed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
    post:
      operationId: createRoom
      summary: Create a room
      description: >-
        Create an empty [room](/api/rooms). The `201` response returns its `room_id` and immutable
        `voice_activity_events` setting. The room starts with no members and no playback. Reuse an `Idempotency-Key`
        when safely retrying the same request.


        **Triggered webhooks:** `room.created` (immediate)


        See [Room lifecycle, member, and playback events](/api/rooms#lifecycle-member-and-playback-events) for complete
        payload schemas and examples.
      tags:
        - rooms
      parameters:
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. See [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for
            details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional key for safely retrying mutating requests. See
            [Idempotency](https://voice-platform.docs.buildwithfern.com/idempotency) for details.
          required: false
          schema:
            type: string
            pattern: ^[a-zA-Z0-9._-]+$
            maxLength: 128
      responses:
        '201':
          description: Room created
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Rooms_createRoom_Response_201'
        '400':
          description: >-
            Missing `Authorization` or malformed Bearer credentials return `invalid_authorization_header`; invalid
            request parameters return `invalid_request`. A syntactically valid credential with an invalid API key
            returns `401 unauthorized` 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 invalid_authorization_header`.
          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
            `{"code":"forbidden","message":"Maximum number of rooms reached for this application"}`.
          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: >-
            Send JSON request bodies with `Content-Type: application/json`. The API rejects an explicitly supplied
            malformed or unsupported media type.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateRoomRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different method, path, query, content type, body, or
            `Operation-Id`. 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 for the applicable per-command, per-room, or per-app scope. The `Retry-After` response
            header gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateRoomRequestTooManyRequestsError'
        '500':
          description: >-
            An unexpected platform failure. Quote `support_id` to support; the technical cause and vendor event
            identifier are never exposed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
        '503':
          description: >-
            When an `Idempotency-Key` was supplied, the idempotency store is unavailable and the request was NOT
            processed; retry with the same key. An operation can document another `503` condition with different
            execution and retry guidance; follow the operation description and the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateRoomRequestServiceUnavailableError'
      requestBody:
        description: Room creation options. Omit `voice_activity_events` to keep member voice-activity webhooks disabled.
        content:
          application/json:
            schema:
              type: object
              properties:
                voice_activity_events:
                  type: boolean
                  description: >-
                    Opt in to `room.member.voice_activity_changed` webhooks for this room. Omission is equivalent to
                    `false`.
  /api/v1/rooms/{room_id}:
    get:
      operationId: getRoomStatus
      summary: Get room status
      description: Return the canonical [room](/api/rooms) resource.
      tags:
        - rooms
      parameters:
        - name: room_id
          in: path
          description: Case-sensitive [room](/api/rooms) identifier.
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. 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` or malformed Bearer credentials return `invalid_authorization_header`; invalid
            request parameters return `invalid_request`. A syntactically valid credential with an invalid API key
            returns `401 unauthorized` 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 invalid_authorization_header`.
          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: >-
            An unexpected platform failure. Quote `support_id` to support; the technical cause and vendor event
            identifier are never exposed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
    delete:
      operationId: deleteRoom
      summary: Delete room
      description: >-
        Delete a [room](/api/rooms). Deletion disconnects all

        members and stops room recording and playback.


        A `202 Accepted` response with `{room_id, status: "deleting"}` confirms

        that the asynchronous deletion request was accepted. Deletion is not yet

        complete.


        **Triggered webhook:** The platform emits `room.deleted` with exactly one of

        these reasons:


        - `reason: "closed"` after room deletion is confirmed.

        - `reason: "timeout"` if confirmation does not arrive.


        See [Room lifecycle, member, and playback events](/api/rooms#lifecycle-member-and-playback-events) for complete
        payload schemas and examples.
      tags:
        - rooms
      parameters:
        - name: room_id
          in: path
          description: Case-sensitive [room](/api/rooms) identifier.
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. 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` or malformed Bearer credentials return `invalid_authorization_header`; invalid
            request parameters return `invalid_request`. A syntactically valid credential with an invalid API key
            returns `401 unauthorized` 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 invalid_authorization_header`.
          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: >-
            An unexpected platform failure. Quote `support_id` to support; the technical cause and vendor event
            identifier are never exposed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
  /api/v1/rooms/{room_id}/members:
    get:
      operationId: listRoomMembers
      summary: List room members
      description: |-
        List active [room members](/api/room-members), sorted by session
        `uuid` in ascending order.

        This endpoint returns one non-paginated result. Omitting `limit` returns every
        member when the full result set is within the system result ceiling. Setting
        `limit` returns at most that many members and sets `has_more` to `true` when
        additional members matched.

        The system checks the full result set against its ceiling before applying
        `limit`. If the full set exceeds the ceiling, the request returns `413` and a
        smaller `limit` cannot make it succeed.
      tags:
        - roomMembers
      parameters:
        - name: room_id
          in: path
          description: Case-sensitive [room](/api/rooms) identifier.
          required: true
          schema:
            type: string
        - name: limit
          in: query
          description: |-
            Sets the maximum number of members in the response. Omitting it returns
            every member when the full result set is within the system ceiling. A
            non-positive value returns `400`.
          required: false
          schema:
            type: integer
            minimum: 1
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. 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 invalid_authorization_header`.
          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 full member set exceeds the system result ceiling. The system checks
            this ceiling before applying `limit`, and the endpoint has no narrowing
            filter. The standard error envelope contains
            `code: result_set_too_large`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ListRoomMembersRequestContentTooLargeError'
        '500':
          description: >-
            An unexpected platform failure. Quote `support_id` to support; the technical cause and vendor event
            identifier are never exposed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
    post:
      operationId: addRoomMember
      summary: Add a session to the room
      description: >-
        **Rate limit: Per room** · **Burst:** 100 · **Refill:** 30 req/s


        Add a session as a [room member](/api/room-members). Omit `muted` to

        join unmuted.


        A `202` response with `status: joining` confirms that the join request was

        accepted. Membership is not yet complete.


        Exactly one of these outcomes applies:


        - If the session is not in another room, the new join starts.

        - If the session is already in this room, the response is `200` with
          `status: already_joined`; another join is not started.
        - If the session has completed joining another room, it is removed from that
          room before the new join starts.
        - If the session is still joining another room, the response is `409`.


        **Triggered webhooks:**


        - `room.member.joined` is emitted after membership in the target room is
          confirmed.
        - Moving a session also emits `room.member.left` for the previous room.


        See [Room lifecycle, member, and playback events](/api/rooms#lifecycle-member-and-playback-events) for complete
        payload schemas and examples.
      tags:
        - roomMembers
      parameters:
        - name: room_id
          in: path
          description: Case-sensitive [room](/api/rooms) identifier.
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. See [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for
            details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional key for safely retrying mutating requests. See
            [Idempotency](https://voice-platform.docs.buildwithfern.com/idempotency) for details.
          required: false
          schema:
            type: string
            pattern: ^[a-zA-Z0-9._-]+$
            maxLength: 128
      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 invalid_authorization_header`.
          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: |-
            The session is still joining another room, a request with
            this `Idempotency-Key` is still in progress (`code: conflict`), or the
            target room is at its member cap (`code: room_full`). The member cap is
            the application's `max_members` value, or the system default of 250 when
            unset. The cap is a member count, not a rate limit, so this response
            has no `Retry-After` header. The body exposes no count, cap, or 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: >-
            Send JSON request bodies with `Content-Type: application/json`. The API rejects an explicitly supplied
            malformed or unsupported media type.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AddRoomMemberRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different method, path, query, content type, body, or
            `Operation-Id`. 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 for the applicable per-command, per-room, or per-app scope. The `Retry-After` response
            header gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AddRoomMemberRequestTooManyRequestsError'
        '500':
          description: >-
            An unexpected platform failure. Quote `support_id` to support; the technical cause and vendor event
            identifier are never exposed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
        '503':
          description: >-
            When an `Idempotency-Key` was supplied, the idempotency store is unavailable and the request was NOT
            processed; retry with the same key. An operation can document another `503` condition with different
            execution and retry guidance; follow 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
                  description: |-
                    Controls whether the member joins muted. Omit this field or set
                    it to `false` to join the member unmuted.
                session_uuid:
                  type: string
                  description: |-
                    Identifies the session to add. This is the same session UUID that
                    `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: |-
        Get one [room member](/api/room-members). `{uuid}` is the
        member's session UUID. It is the same identifier returned by
        `GET /api/v1/rooms/{room_id}/members`.

        The response uses the same `{uuid, muted}` member object as the list
        endpoint. Voice activity is not included in this object. Receive voice
        activity changes through the `room.member.voice_activity_changed` webhook when
        the room was created with `voice_activity_events: true`.
      tags:
        - roomMembers
      parameters:
        - name: room_id
          in: path
          description: Case-sensitive [room](/api/rooms) identifier.
          required: true
          schema:
            type: string
        - name: uuid
          in: path
          description: '[Session](/api/sessions) identifier.'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. 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` or malformed Bearer credentials return `invalid_authorization_header`; invalid
            request parameters return `invalid_request`. A syntactically valid credential with an invalid API key
            returns `401 unauthorized` 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 invalid_authorization_header`.
          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: >-
            An unexpected platform failure. Quote `support_id` to support; the technical cause and vendor event
            identifier are never exposed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
    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)


        See [Room lifecycle, member, and playback events](/api/rooms#lifecycle-member-and-playback-events) for complete
        payload schemas and examples.
      tags:
        - roomMembers
      parameters:
        - name: room_id
          in: path
          description: Case-sensitive [room](/api/rooms) identifier.
          required: true
          schema:
            type: string
        - name: uuid
          in: path
          description: '[Session](/api/sessions) identifier.'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. 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` or malformed Bearer credentials return `invalid_authorization_header`; invalid
            request parameters return `invalid_request`. A syntactically valid credential with an invalid API key
            returns `401 unauthorized` 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 invalid_authorization_header`.
          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 for the applicable per-command, per-room, or per-app scope. The `Retry-After` response
            header gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RemoveRoomMemberRequestTooManyRequestsError'
        '500':
          description: >-
            An unexpected platform failure. Quote `support_id` to support; the technical cause and vendor event
            identifier are never exposed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
  /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)


        See [Room lifecycle, member, and playback events](/api/rooms#lifecycle-member-and-playback-events) for complete
        payload schemas and examples.
      tags:
        - roomMembers
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) identifier.'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. See [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for
            details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional key for safely retrying mutating requests. See
            [Idempotency](https://voice-platform.docs.buildwithfern.com/idempotency) for details.
          required: false
          schema:
            type: string
            pattern: ^[a-zA-Z0-9._-]+$
            maxLength: 128
      responses:
        '202':
          description: Muting member
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Room Members_muteRoomMember_Response_202'
        '400':
          description: >-
            Missing `Authorization` or malformed Bearer credentials return `invalid_authorization_header`; invalid
            request parameters return `invalid_request`. A syntactically valid credential with an invalid API key
            returns `401 unauthorized` 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 invalid_authorization_header`.
          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:
                $ref: '#/components/schemas/MuteRoomMemberRequestConflictError'
        '413':
          description: Request body exceeds the endpoint's size limit.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/MuteRoomMemberRequestContentTooLargeError'
        '415':
          description: >-
            Send JSON request bodies with `Content-Type: application/json`. The API rejects an explicitly supplied
            malformed or unsupported media type.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/MuteRoomMemberRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different method, path, query, content type, body, or
            `Operation-Id`. A key maps to one request; use a new key. See the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/MuteRoomMemberRequestUnprocessableEntityError'
        '500':
          description: >-
            An unexpected platform failure. Quote `support_id` to support; the technical cause and vendor event
            identifier are never exposed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
        '503':
          description: >-
            When an `Idempotency-Key` was supplied, the idempotency store is unavailable and the request was NOT
            processed; retry with the same key. An operation can document another `503` condition with different
            execution and retry guidance; follow the operation description and the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/MuteRoomMemberRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties: {}
  /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)


        See [Room lifecycle, member, and playback events](/api/rooms#lifecycle-member-and-playback-events) for complete
        payload schemas and examples.
      tags:
        - roomMembers
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) identifier.'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. See [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for
            details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional key for safely retrying mutating requests. See
            [Idempotency](https://voice-platform.docs.buildwithfern.com/idempotency) for details.
          required: false
          schema:
            type: string
            pattern: ^[a-zA-Z0-9._-]+$
            maxLength: 128
      responses:
        '202':
          description: Unmuting member
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Room Members_unmuteRoomMember_Response_202'
        '400':
          description: >-
            Missing `Authorization` or malformed Bearer credentials return `invalid_authorization_header`; invalid
            request parameters return `invalid_request`. A syntactically valid credential with an invalid API key
            returns `401 unauthorized` 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 invalid_authorization_header`.
          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:
                $ref: '#/components/schemas/UnmuteRoomMemberRequestConflictError'
        '413':
          description: Request body exceeds the endpoint's size limit.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UnmuteRoomMemberRequestContentTooLargeError'
        '415':
          description: >-
            Send JSON request bodies with `Content-Type: application/json`. The API rejects an explicitly supplied
            malformed or unsupported media type.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UnmuteRoomMemberRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different method, path, query, content type, body, or
            `Operation-Id`. A key maps to one request; use a new key. See the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UnmuteRoomMemberRequestUnprocessableEntityError'
        '500':
          description: >-
            An unexpected platform failure. Quote `support_id` to support; the technical cause and vendor event
            identifier are never exposed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
        '503':
          description: >-
            When an `Idempotency-Key` was supplied, the idempotency store is unavailable and the request was NOT
            processed; retry with the same key. An operation can document another `503` condition with different
            execution and retry guidance; follow the operation description and the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UnmuteRoomMemberRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties: {}
  /v1/sessions/{uuid}/room/volume:
    post:
      operationId: setRoomMemberVolume
      summary: Set room member volume
      description: >-
        Set the volume for a single [room member](/api/room-members), addressed by the member's

        session UUID. This setting is independent of the room playback volume (`POST /rooms/{room_id}/playback/volume`).


        Member volume uses a coarse 1-9 notch scale:


        - `1`: quietest

        - `5`: normal/unchanged

        - `9`: loudest


        This differs from the 0-200 room playback scale. `1` is the quietest

        setting but is NOT silence; to silence a member use the mute command instead.


        `direction` is named relative to the Room member:


        - `to_member`: how loudly the member hears the Room

        - `from_member`: how loudly the Room hears the member

        - `both`: apply the setting in both directions


        The response acknowledges asynchronous admission. Exactly one terminal webhook follows:


        - `room.member.volume_changed` after every requested direction succeeds.

        - `room.member.volume_change_failed` after a confirmed full or partial execution failure.


        See [Room lifecycle, member, and playback events](/api/rooms#lifecycle-member-and-playback-events) for complete
        payload schemas and examples.
      tags:
        - roomMembers
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) identifier.'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. See [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for
            details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional key for safely retrying mutating requests. See
            [Idempotency](https://voice-platform.docs.buildwithfern.com/idempotency) for details.
          required: false
          schema:
            type: string
            pattern: ^[a-zA-Z0-9._-]+$
            maxLength: 128
        - name: Operation-Id
          in: header
          description: >-
            optional client-supplied lowercase RFC-4122 v4 UUID returned as operation_uuid; platform generates one when
            omitted; correlation metadata distinct from Idempotency-Key.
          required: false
          schema:
            type: string
            format: uuid
            pattern: ^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
      responses:
        '202':
          description: Command accepted for async execution
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AsyncCommandResponse'
        '400':
          description: >-
            Missing `Authorization` or malformed Bearer credentials return `invalid_authorization_header`; invalid
            request parameters return `invalid_request`. A syntactically valid credential with an invalid API key
            returns `401 unauthorized` 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 invalid_authorization_header`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SetRoomMemberVolumeRequestUnauthorizedError'
        '404':
          description: Session is not in any room.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SetRoomMemberVolumeRequestNotFoundError'
        '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:
                $ref: '#/components/schemas/SetRoomMemberVolumeRequestConflictError'
        '413':
          description: Request body exceeds the endpoint's size limit.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SetRoomMemberVolumeRequestContentTooLargeError'
        '415':
          description: >-
            Send JSON request bodies with `Content-Type: application/json`. The API rejects an explicitly supplied
            malformed or unsupported media type.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SetRoomMemberVolumeRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different method, path, query, content type, body, or
            `Operation-Id`. A key maps to one request; use a new key. See the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SetRoomMemberVolumeRequestUnprocessableEntityError'
        '500':
          description: >-
            An unexpected platform failure. Quote `support_id` to support; the technical cause and vendor event
            identifier are never exposed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
        '503':
          description: >-
            When an `Idempotency-Key` was supplied, the idempotency store is unavailable and the request was NOT
            processed; retry with the same key. An operation can document another `503` condition with different
            execution and retry guidance; follow the operation description and the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SetRoomMemberVolumeRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties:
                direction:
                  $ref: '#/components/schemas/V1SessionsUuidRoomVolumePostRequestBodyContentApplicationJsonSchemaDirection'
                  description: >-
                    Room-member-relative direction. to_member = member hears Room; from_member = Room hears member; both
                    = both.
                volume:
                  type: integer
                  minimum: 1
                  maximum: 9
                  description: Member volume (1-9). 5 = normal/unchanged, 1 = quietest, 9 = loudest.
              required:
                - direction
                - volume
  /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


        Play one or more finite WAV or MP3 files in order with `type: files`, or join a hosted HTTP/HTTPS AAC source at
        its current live position with `type: stream`. Live streams do not support seek or loop.


        The platform validates and prepares every source before admission. If it cannot prepare a source, the request
        returns a synchronous HTTP error and emits no playback webhook. If room playback is already active, the request
        returns `409`.


        A `202` response confirms admission. After admission, the platform emits `room.playback.ended` when playback
        finishes naturally or is stopped through the API. It emits `room.playback.failed` if playback fails or times
        out.


        See [Room lifecycle, member, and playback events](/api/rooms#lifecycle-member-and-playback-events) for complete
        payload schemas and examples.
      tags:
        - roomPlayback
      parameters:
        - name: room_id
          in: path
          description: Case-sensitive [room](/api/rooms) identifier.
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. See [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for
            details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional key for safely retrying mutating requests. See
            [Idempotency](https://voice-platform.docs.buildwithfern.com/idempotency) for details.
          required: false
          schema:
            type: string
            pattern: ^[a-zA-Z0-9._-]+$
            maxLength: 128
        - name: Operation-Id
          in: header
          description: >-
            optional client-supplied lowercase RFC-4122 v4 UUID returned as operation_uuid; platform generates one when
            omitted; correlation metadata distinct from Idempotency-Key.
          required: false
          schema:
            type: string
            format: uuid
            pattern: ^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
      responses:
        '202':
          description: Room playback command accepted for asynchronous execution
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RoomAsyncCommandResponse'
        '400':
          description: >-
            Missing `Authorization` or malformed Bearer credentials return `invalid_authorization_header`; invalid
            request parameters return `invalid_request`. A syntactically valid credential with an invalid API key
            returns `401 unauthorized` 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 invalid_authorization_header`.
          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: >-
            Send JSON request bodies with `Content-Type: application/json`. The API rejects an explicitly supplied
            malformed or unsupported media type.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PlayAudioInRoomRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different method, path, query, content type, body, or
            `Operation-Id`. 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 for the applicable per-command, per-room, or per-app scope. The `Retry-After` response
            header gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PlayAudioInRoomRequestTooManyRequestsError'
        '500':
          description: >-
            An unexpected platform failure. Quote `support_id` to support; the technical cause and vendor event
            identifier are never exposed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
        '502':
          description: The response identifies why source admission failed and whether retrying may succeed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PlaybackSourceErrorResponse'
        '503':
          description: |-
            The idempotency store is unavailable, the room was temporarily unreachable,
            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/pause:
    post:
      operationId: pauseRoomPlayback
      summary: Pause room playback
      description: >-
        Pause room playback. Repeating the command is safe even if the first result was ambiguous.


        Reuse the same optional `Operation-Id` header within 10 minutes only when retrying the same admission; reuse for
        a different command is rejected.


        The 202 response confirms admission.
      tags:
        - roomPlayback
      parameters:
        - name: room_id
          in: path
          description: Case-sensitive [room](/api/rooms) identifier.
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. See [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for
            details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional key for safely retrying mutating requests. See
            [Idempotency](https://voice-platform.docs.buildwithfern.com/idempotency) for details.
          required: false
          schema:
            type: string
            pattern: ^[a-zA-Z0-9._-]+$
            maxLength: 128
        - name: Operation-Id
          in: header
          description: >-
            optional client-supplied lowercase RFC-4122 v4 UUID returned as operation_uuid; platform generates one when
            omitted; correlation metadata distinct from Idempotency-Key.
          required: false
          schema:
            type: string
            format: uuid
            pattern: ^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
      responses:
        '202':
          description: Room playback command accepted for asynchronous execution
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RoomAsyncCommandResponse'
        '400':
          description: >-
            Missing `Authorization` or malformed Bearer credentials return `invalid_authorization_header`; invalid
            request parameters return `invalid_request`. A syntactically valid credential with an invalid API key
            returns `401 unauthorized` 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 invalid_authorization_header`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PauseRoomPlaybackRequestUnauthorizedError'
        '404':
          description: Room not found
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PauseRoomPlaybackRequestNotFoundError'
        '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/PauseRoomPlaybackRequestConflictError'
        '413':
          description: Request body exceeds the endpoint's size limit.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PauseRoomPlaybackRequestContentTooLargeError'
        '415':
          description: >-
            Send JSON request bodies with `Content-Type: application/json`. The API rejects an explicitly supplied
            malformed or unsupported media type.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PauseRoomPlaybackRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different method, path, query, content type, body, or
            `Operation-Id`. A key maps to one request; use a new key. See the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PauseRoomPlaybackRequestUnprocessableEntityError'
        '429':
          description: >-
            Rate limit exceeded for the applicable per-command, per-room, or per-app scope. The `Retry-After` response
            header gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PauseRoomPlaybackRequestTooManyRequestsError'
        '500':
          description: >-
            An unexpected platform failure. Quote `support_id` to support; the technical cause and vendor event
            identifier are never exposed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
        '503':
          description: The idempotency store or room was temporarily unavailable, so the command was not accepted.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PauseRoomPlaybackRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties: {}
  /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 Recording remains active while the room is empty and across service
        recovery.

        A `202` response confirms that the start request was accepted. It does not
        mean the Recording is available yet. The response also includes the current
        Recording details:

        - The `recording_uuid`.
        - A signed, time-bounded public `media_url`, without internal paths.

        Availability is reported separately:

        - If the Recording becomes available, the platform emits
          `recording.became_available`.
        - If the Recording does not become available, it remains active and the
          platform does not emit `recording.failed`.

        When you later stop the Recording, the platform emits `recording.ended`.

        See [Recording lifecycle events](/api/recording#lifecycle-events) for complete payload schemas and examples.
      tags:
        - roomPlayback
      parameters:
        - name: room_id
          in: path
          description: Case-sensitive [room](/api/rooms) identifier.
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. See [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for
            details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional key for safely retrying mutating requests. See
            [Idempotency](https://voice-platform.docs.buildwithfern.com/idempotency) for details.
          required: false
          schema:
            type: string
            pattern: ^[a-zA-Z0-9._-]+$
            maxLength: 128
        - name: Operation-Id
          in: header
          description: >-
            optional client-supplied lowercase RFC-4122 v4 UUID returned as operation_uuid; platform generates one when
            omitted; correlation metadata distinct from Idempotency-Key.
          required: false
          schema:
            type: string
            format: uuid
            pattern: ^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
      responses:
        '202':
          description: Room recording start accepted
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Room Playback_startRoomRecording_Response_202'
        '400':
          description: >-
            Missing `Authorization` or malformed Bearer credentials return `invalid_authorization_header`; invalid
            request parameters return `invalid_request`. A syntactically valid credential with an invalid API key
            returns `401 unauthorized` 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 invalid_authorization_header`.
          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 method, path, query, content type, body, or
            `Operation-Id`. 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 for the applicable per-command, per-room, or per-app scope. The `Retry-After` response
            header gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StartRoomRecordingRequestTooManyRequestsError'
        '500':
          description: >-
            An unexpected platform failure. Quote `support_id` to support; the technical cause and vendor event
            identifier are never exposed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
        '503':
          description: |-
            Recording is unavailable, the room was temporarily unreachable, 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).

        A `202 Accepted` response confirms that the stop request was accepted. It
        does not mean the recording file is closed or final audio is available. The
        flat response includes the request acknowledgement and the same Recording
        identity.

        Exactly one of these outcomes applies:

        - If the room has an active Recording, the stop request is accepted.
        - If the room has no active Recording, the response is
          `409 recording_not_active`; no recording command is sent and no event is
          emitted.

        This operation does not support `Idempotency-Key`.

        **Triggered webhook:**

        - `recording.ended` is emitted immediately after the recording file is
          closed.
        - It carries a fresh signed public URL for the same `recording_uuid`.
        - A `media_url` request started at that boundary may briefly continue
          following the growing Recording until finalization completes.

        See [Recording lifecycle events](/api/recording#lifecycle-events) for complete payload schemas and examples.
      tags:
        - roomPlayback
      parameters:
        - name: room_id
          in: path
          description: Case-sensitive [room](/api/rooms) identifier.
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. See [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for
            details.
          required: true
          schema:
            type: string
        - name: Operation-Id
          in: header
          description: >-
            optional client-supplied lowercase RFC-4122 v4 UUID returned as operation_uuid; platform generates one when
            omitted; correlation metadata distinct from Idempotency-Key.
          required: false
          schema:
            type: string
            format: uuid
            pattern: ^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
      responses:
        '202':
          description: Room recording stop accepted
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Room Playback_stopRoomRecording_Response_202'
        '400':
          description: >-
            Missing `Authorization` or malformed Bearer credentials return `invalid_authorization_header`; invalid
            request parameters return `invalid_request`. A syntactically valid credential with an invalid API key
            returns `401 unauthorized` 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 invalid_authorization_header`.
          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 for the applicable per-command, per-room, or per-app scope. The `Retry-After` response
            header gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StopRoomRecordingRequestTooManyRequestsError'
        '500':
          description: >-
            An unexpected platform failure. Quote `support_id` to support; the technical cause and vendor event
            identifier are never exposed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
        '503':
          description: The room was temporarily unreachable, so no stop was accepted.
          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

        Seek the room's current playback by a relative, signed offset. This command
        shares the room playback seek bucket (`room.playback.seek`).
        `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: Case-sensitive [room](/api/rooms) identifier.
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. See [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for
            details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional key for safely retrying mutating requests. See
            [Idempotency](https://voice-platform.docs.buildwithfern.com/idempotency) for details.
          required: false
          schema:
            type: string
            pattern: ^[a-zA-Z0-9._-]+$
            maxLength: 128
        - name: Operation-Id
          in: header
          description: >-
            optional client-supplied lowercase RFC-4122 v4 UUID returned as operation_uuid; platform generates one when
            omitted; correlation metadata distinct from Idempotency-Key.
          required: false
          schema:
            type: string
            format: uuid
            pattern: ^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
      responses:
        '202':
          description: Room playback command accepted for asynchronous execution
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RoomAsyncCommandResponse'
        '400':
          description: >-
            Missing `Authorization` or malformed Bearer credentials return `invalid_authorization_header`; invalid
            request parameters return `invalid_request`. A syntactically valid credential with an invalid API key
            returns `401 unauthorized` 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 invalid_authorization_header`.
          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: >-
            Send JSON request bodies with `Content-Type: application/json`. The API rejects an explicitly supplied
            malformed or unsupported media type.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SeekRoomPlaybackRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different method, path, query, content type, body, or
            `Operation-Id`. 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 for the applicable per-command, per-room, or per-app scope. The `Retry-After` response
            header gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SeekRoomPlaybackRequestTooManyRequestsError'
        '500':
          description: >-
            An unexpected platform failure. Quote `support_id` to support; the technical cause and vendor event
            identifier are never exposed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
        '503':
          description: >-
            When an `Idempotency-Key` was supplied, the idempotency store is unavailable and the request was NOT
            processed; retry with the same key. An operation can document another `503` condition with different
            execution and retry guidance; follow 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. The 202 response confirms admission.


        **Triggered webhook:** `room.playback.ended` with `reason: stopped` (terminal for the interrupted playback).


        See [Room lifecycle, member, and playback events](/api/rooms#lifecycle-member-and-playback-events) for complete
        payload schemas and examples.
      tags:
        - roomPlayback
      parameters:
        - name: room_id
          in: path
          description: Case-sensitive [room](/api/rooms) identifier.
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. See [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for
            details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional key for safely retrying mutating requests. See
            [Idempotency](https://voice-platform.docs.buildwithfern.com/idempotency) for details.
          required: false
          schema:
            type: string
            pattern: ^[a-zA-Z0-9._-]+$
            maxLength: 128
        - name: Operation-Id
          in: header
          description: >-
            optional client-supplied lowercase RFC-4122 v4 UUID returned as operation_uuid; platform generates one when
            omitted; correlation metadata distinct from Idempotency-Key.
          required: false
          schema:
            type: string
            format: uuid
            pattern: ^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
      responses:
        '202':
          description: Room playback command accepted for asynchronous execution
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RoomAsyncCommandResponse'
        '400':
          description: >-
            Missing `Authorization` or malformed Bearer credentials return `invalid_authorization_header`; invalid
            request parameters return `invalid_request`. A syntactically valid credential with an invalid API key
            returns `401 unauthorized` 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 invalid_authorization_header`.
          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'
        '413':
          description: Request body exceeds the endpoint's size limit.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StopRoomPlaybackRequestContentTooLargeError'
        '415':
          description: >-
            Send JSON request bodies with `Content-Type: application/json`. The API rejects an explicitly supplied
            malformed or unsupported media type.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StopRoomPlaybackRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different method, path, query, content type, body, or
            `Operation-Id`. A key maps to one request; use a new key. See the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StopRoomPlaybackRequestUnprocessableEntityError'
        '429':
          description: >-
            Rate limit exceeded for the applicable per-command, per-room, or per-app scope. The `Retry-After` response
            header gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StopRoomPlaybackRequestTooManyRequestsError'
        '500':
          description: >-
            An unexpected platform failure. Quote `support_id` to support; the technical cause and vendor event
            identifier are never exposed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
        '503':
          description: >-
            The idempotency store or room was temporarily unavailable, or the stop could not be confirmed; no stop was
            accepted.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StopRoomPlaybackRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties: {}
  /api/v1/rooms/{room_id}/playback/volume:
    post:
      operationId: setRoomVolume
      summary: Set room playback volume
      description: |-
        Set 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.

        The 202 response confirms admission.
      tags:
        - roomPlayback
      parameters:
        - name: room_id
          in: path
          description: Case-sensitive [room](/api/rooms) identifier.
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. See [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for
            details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional key for safely retrying mutating requests. See
            [Idempotency](https://voice-platform.docs.buildwithfern.com/idempotency) for details.
          required: false
          schema:
            type: string
            pattern: ^[a-zA-Z0-9._-]+$
            maxLength: 128
        - name: Operation-Id
          in: header
          description: >-
            optional client-supplied lowercase RFC-4122 v4 UUID returned as operation_uuid; platform generates one when
            omitted; correlation metadata distinct from Idempotency-Key.
          required: false
          schema:
            type: string
            format: uuid
            pattern: ^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
      responses:
        '202':
          description: Room playback command accepted for asynchronous execution
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RoomAsyncCommandResponse'
        '400':
          description: >-
            Missing `Authorization` or malformed Bearer credentials return `invalid_authorization_header`; invalid
            request parameters return `invalid_request`. A syntactically valid credential with an invalid API key
            returns `401 unauthorized` 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 invalid_authorization_header`.
          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: >-
            Send JSON request bodies with `Content-Type: application/json`. The API rejects an explicitly supplied
            malformed or unsupported media type.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SetRoomVolumeRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different method, path, query, content type, body, or
            `Operation-Id`. 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 for the applicable per-command, per-room, or per-app scope. The `Retry-After` response
            header gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SetRoomVolumeRequestTooManyRequestsError'
        '500':
          description: >-
            An unexpected platform failure. Quote `support_id` to support; the technical cause and vendor event
            identifier are never exposed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
        '503':
          description: >-
            When an `Idempotency-Key` was supplied, the idempotency store is unavailable and the request was NOT
            processed; retry with the same key. An operation can document another `503` condition with different
            execution and retry guidance; follow 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
                  minimum: 0
                  maximum: 200
                  description: Playback volume (0-200). 100 = normal/unchanged, 0 = mute, above 100 boosts up to 200.
              required:
                - volume
  /api/v1/rooms/{room_id}/playback/resume:
    post:
      operationId: resumeRoomPlayback
      summary: Resume room playback
      description: >-
        Resume room playback. Repeating the command is safe even if the first result was ambiguous.


        Reuse the same optional `Operation-Id` header within 10 minutes only when retrying the same admission; reuse for
        a different command is rejected.


        The 202 response confirms admission.
      tags:
        - roomPlayback
      parameters:
        - name: room_id
          in: path
          description: Case-sensitive [room](/api/rooms) identifier.
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. See [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for
            details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional key for safely retrying mutating requests. See
            [Idempotency](https://voice-platform.docs.buildwithfern.com/idempotency) for details.
          required: false
          schema:
            type: string
            pattern: ^[a-zA-Z0-9._-]+$
            maxLength: 128
        - name: Operation-Id
          in: header
          description: >-
            optional client-supplied lowercase RFC-4122 v4 UUID returned as operation_uuid; platform generates one when
            omitted; correlation metadata distinct from Idempotency-Key.
          required: false
          schema:
            type: string
            format: uuid
            pattern: ^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
      responses:
        '202':
          description: Room playback command accepted for asynchronous execution
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RoomAsyncCommandResponse'
        '400':
          description: >-
            Missing `Authorization` or malformed Bearer credentials return `invalid_authorization_header`; invalid
            request parameters return `invalid_request`. A syntactically valid credential with an invalid API key
            returns `401 unauthorized` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ResumeRoomPlaybackRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400 invalid_authorization_header`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ResumeRoomPlaybackRequestUnauthorizedError'
        '404':
          description: Room not found
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ResumeRoomPlaybackRequestNotFoundError'
        '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/ResumeRoomPlaybackRequestConflictError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different method, path, query, content type, body, or
            `Operation-Id`. A key maps to one request; use a new key. See the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ResumeRoomPlaybackRequestUnprocessableEntityError'
        '429':
          description: >-
            Rate limit exceeded for the applicable per-command, per-room, or per-app scope. The `Retry-After` response
            header gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ResumeRoomPlaybackRequestTooManyRequestsError'
        '500':
          description: >-
            An unexpected platform failure. Quote `support_id` to support; the technical cause and vendor event
            identifier are never exposed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
        '503':
          description: The idempotency store or room was temporarily unavailable, so the command was not accepted.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ResumeRoomPlaybackRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties: {}
  /v1/sessions/{uuid}/recordings:
    get:
      operationId: listSessionRecordings
      summary: List session recordings
      description: List the active and stopping recordings that belong to this Session.
      tags:
        - recording
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) identifier.'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. See [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for
            details.
          required: true
          schema:
            type: string
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SessionRecordingListBody'
        '400':
          description: >-
            Missing `Authorization` or malformed Bearer credentials return `invalid_authorization_header`; invalid
            request parameters return `invalid_request`. A syntactically valid credential with an invalid API key
            returns `401 unauthorized` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ListSessionRecordingsRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400 invalid_authorization_header`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ListSessionRecordingsRequestUnauthorizedError'
        '404':
          description: The requested resource was not found or is not owned by the authenticated app.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ListSessionRecordingsRequestNotFoundError'
        '503':
          description: Recording state unavailable
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ListSessionRecordingsRequestServiceUnavailableError'
    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.


        The `202 Accepted` response confirms that the command was admitted. It does not confirm that recording has
        started or that recorded audio is available. Retain the returned `recording_uuid` to address this recording, and
        use the returned `operation_uuid` to correlate the recording lifecycle webhooks below.


        Send `POST /v1/sessions/{uuid}/recordings` as soon as you receive the Session's `session_uuid`. Choose the
        capture boundary with `start_only_after_answer`:


        - By default, inbound and outbound phone Sessions start recording as soon as the current media path permits,
        including available early media.

        - Set `start_only_after_answer` to `true` to durably wait for the canonical answer instead. If a waiting Session
        ends first, `recording.failed` is emitted.


        Choose independently for each recording whether to include redacted periods and periods without recordable
        audio. Omit `include_gaps` or set it to `false` to remove those gaps from the artifact. Set it to `true` to
        include the gaps as silence.


        A Session may have multiple active recordings, including duplicate `both` + `mono` recordings. Voice activity
        events and their detector configuration are optional and independent for every recording.


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


        **Triggered webhooks:**


        - `recording.became_available` carries signed `media_url` and
          `live_url` capabilities; `recording.failed` is emitted instead if the recording
          does not become available.
        - 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.

        Use `media_url` to start at byte zero and follow the growing Recording until

        EOF. After finalization, the same URL serves a finite, range-capable WAV. Use

        `live_url` to join near the current position.

        Anyone with either URL can access its capability until it expires.

        By default, it expires 24 hours after the lifecycle event is emitted.


        > **Tip: Minimize confirmation playback delay.** If you plan to play a recording back

        > to the caller for confirmation, start streaming the `media_url` from the

        > beginning into an S3 multipart upload as soon as

        > [`recording.became_available`](/webhooks/recording-events#recordingbecame_available)

        > provides it. After

        > [`recording.ended`](/webhooks/recording-events#recordingended), let the source

        > stream reach EOF, then complete the multipart upload. Because most of the audio

        > is already in S3, you can start playback without first transferring the entire

        > recording after it ends.

        >

        > Use `media_url` for this workflow. The `live_url` starts at the live edge and

        > does not include audio recorded before you connect.


        See [Recording lifecycle events](/api/recording#lifecycle-events) for complete payload schemas and examples.
      tags:
        - recording
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) identifier.'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. See [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for
            details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional key for safely retrying mutating requests. See
            [Idempotency](https://voice-platform.docs.buildwithfern.com/idempotency) for details.
          required: false
          schema:
            type: string
            pattern: ^[a-zA-Z0-9._-]+$
            maxLength: 128
        - name: Operation-Id
          in: header
          description: >-
            optional client-supplied lowercase RFC-4122 v4 UUID returned as operation_uuid; platform generates one when
            omitted; correlation metadata distinct from Idempotency-Key.
          required: false
          schema:
            type: string
            format: uuid
            pattern: ^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
      responses:
        '202':
          description: Recording accepted
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Recording_startRecording_Response_202'
        '400':
          description: >-
            Missing `Authorization` or malformed Bearer credentials return `invalid_authorization_header`; invalid
            request parameters return `invalid_request`. A syntactically valid credential with an invalid API key
            returns `401 unauthorized` 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 invalid_authorization_header`.
          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: >-
            Send JSON request bodies with `Content-Type: application/json`. The API rejects an explicitly supplied
            malformed or unsupported media type.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StartRecordingRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different method, path, query, content type, body, or
            `Operation-Id`. 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 for the applicable per-command, per-room, or per-app scope. The `Retry-After` response
            header gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StartRecordingRequestTooManyRequestsError'
        '500':
          description: >-
            An unexpected platform failure. Quote `support_id` to support; the technical cause and vendor event
            identifier are never exposed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
        '503':
          description: |-
            Recording is unavailable, or the idempotency store is unavailable.
            In either case no recording starts 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:
                channels:
                  $ref: '#/components/schemas/V1SessionsUuidRecordingsPostRequestBodyContentApplicationJsonSchemaChannels'
                  description: Output channel layout. Phase 1 supports `mono`.
                direction:
                  $ref: '#/components/schemas/V1SessionsUuidRecordingsPostRequestBodyContentApplicationJsonSchemaDirection'
                  description: Audio direction relative to the Session. Phase 1 supports `both`.
                enable_voice_activity_events:
                  type: boolean
                  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.
                    Omit this field or set it to `false` to disable these events.
                    Not supported for `type: ws` sessions or room recordings.
                include_gaps:
                  type: boolean
                  description: >-
                    Controls whether redacted periods and periods without recordable audio are included in the
                    recording's duration. Omit this field or set it to `false` to remove those gaps from the artifact.
                    Set it to `true` to include the gaps as silence.
                start_only_after_answer:
                  type: boolean
                  description: |-
                    When `true` on an inbound or outbound phone Session that has
                    not answered, durably admit the request and wait for the canonical
                    answer before starting. Omit this field or set it to `false` to start
                    as soon as the current media path permits, including available early
                    media. Already-answered and `type: ws` Sessions keep their
                    immediate behavior.
                voice_activity_config:
                  $ref: >-
                    #/components/schemas/V1SessionsUuidRecordingsPostRequestBodyContentApplicationJsonSchemaVoiceActivityConfig
                  description: |-
                    Required tuning when voice activity events are enabled. Supplying
                    this object requires
                    `enable_voice_activity_events: true`; otherwise the request is
                    rejected.
              required:
                - channels
                - direction
  /v1/sessions/{uuid}/recordings/{recording_uuid}:
    get:
      operationId: getSessionRecording
      summary: Get a session recording
      description: Get the active or stopping recording identified by `recording_uuid`.
      tags:
        - recording
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) identifier.'
          required: true
          schema:
            type: string
        - name: recording_uuid
          in: path
          required: true
          schema:
            type: string
            pattern: ^rec_[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. See [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for
            details.
          required: true
          schema:
            type: string
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SessionRecordingListBody'
        '400':
          description: >-
            Missing `Authorization` or malformed Bearer credentials return `invalid_authorization_header`; invalid
            request parameters return `invalid_request`. A syntactically valid credential with an invalid API key
            returns `401 unauthorized` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/GetSessionRecordingRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400 invalid_authorization_header`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/GetSessionRecordingRequestUnauthorizedError'
        '404':
          description: The requested resource was not found or is not owned by the authenticated app.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/GetSessionRecordingRequestNotFoundError'
        '503':
          description: Recording state unavailable
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/GetSessionRecordingRequestServiceUnavailableError'
  /v1/sessions/{uuid}/recordings/{recording_uuid}/stop:
    post:
      operationId: stopRecording
      summary: Stop recording
      description: >-
        **Rate limit: Per command** · **Burst:** 20 · **Refill:** 20 req/s


        Stop the [Recording](/api/recording) identified by `recording_uuid`.


        The `202 Accepted` response confirms that the command was admitted. It does not confirm that the recording has
        stopped or that the final audio is available.


        **Later lifecycle outcomes:**


        - `recording.ended` is emitted immediately after the recording file is closed. It carries `recording_uuid`, the
        signed public `media_url`, the `operation_uuid` of the originating recording-create request, and `duration`.

        - A `media_url` request started at that boundary may briefly remain on the growing-recording path while
        finalization completes.

        - A `recording.failed` event is not always final. If a later stop command is accepted, the same recording also
        emits `recording.ended`.


        The signed `media_url` carried by `recording.ended` expires 24 hours after

        that event is emitted by default.

        After internal finalization it supports HTTP Range requests.


        See [Recording lifecycle events](/api/recording#lifecycle-events) for complete payload schemas and examples.
      tags:
        - recording
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) identifier.'
          required: true
          schema:
            type: string
        - name: recording_uuid
          in: path
          required: true
          schema:
            type: string
            pattern: ^rec_[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. See [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for
            details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional key for safely retrying mutating requests. See
            [Idempotency](https://voice-platform.docs.buildwithfern.com/idempotency) for details.
          required: false
          schema:
            type: string
            pattern: ^[a-zA-Z0-9._-]+$
            maxLength: 128
        - name: Operation-Id
          in: header
          description: >-
            optional client-supplied lowercase RFC-4122 v4 UUID returned as operation_uuid; platform generates one when
            omitted; correlation metadata distinct from Idempotency-Key.
          required: false
          schema:
            type: string
            format: uuid
            pattern: ^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
      responses:
        '202':
          description: Command accepted for async execution
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AsyncCommandResponse'
        '400':
          description: >-
            Missing `Authorization` or malformed Bearer credentials return `invalid_authorization_header`; invalid
            request parameters return `invalid_request`. A syntactically valid credential with an invalid API key
            returns `401 unauthorized` 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 invalid_authorization_header`.
          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: >-
            Send JSON request bodies with `Content-Type: application/json`. The API rejects an explicitly supplied
            malformed or unsupported media type.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StopRecordingRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different method, path, query, content type, body, or
            `Operation-Id`. 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 for the applicable per-command, per-room, or per-app scope. The `Retry-After` response
            header gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StopRecordingRequestTooManyRequestsError'
        '500':
          description: >-
            An unexpected platform failure. Quote `support_id` to support; the technical cause and vendor event
            identifier are never exposed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
        '503':
          description: >-
            When an `Idempotency-Key` was supplied, the idempotency store is unavailable and the request was NOT
            processed; retry with the same key. An operation can document another `503` condition with different
            execution and retry guidance; follow the operation description and the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StopRecordingRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties: {}
  /v1/sessions/{uuid}/recordings/{recording_uuid}/mask:
    post:
      operationId: maskRecording
      summary: Mask (pause writing) the active recording
      description: |-
        **Rate limit: Per command** · **Burst:** 20 · **Refill:** 20 req/s

        Mask the recording identified by `recording_uuid`, for example, to redact a
        card-number segment. The recording continues, but audio received while it is
        masked is omitted. Resume writing with this recording's `unmask` endpoint.

        Requires that exact recording to be active; returns `404 Not Found` if it is not
        in progress (the call is unaffected). The `202 Accepted` response confirms
        that the command was admitted, not that masking has taken effect. This
        operation does not emit a completion webhook.

        See [Recording lifecycle events](/api/recording#lifecycle-events) for complete payload schemas and examples.
      tags:
        - recording
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) identifier.'
          required: true
          schema:
            type: string
        - name: recording_uuid
          in: path
          required: true
          schema:
            type: string
            pattern: ^rec_[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. See [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for
            details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional key for safely retrying mutating requests. See
            [Idempotency](https://voice-platform.docs.buildwithfern.com/idempotency) for details.
          required: false
          schema:
            type: string
            pattern: ^[a-zA-Z0-9._-]+$
            maxLength: 128
        - name: Operation-Id
          in: header
          description: >-
            optional client-supplied lowercase RFC-4122 v4 UUID returned as operation_uuid; platform generates one when
            omitted; correlation metadata distinct from Idempotency-Key.
          required: false
          schema:
            type: string
            format: uuid
            pattern: ^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
      responses:
        '202':
          description: Command accepted for async execution
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AsyncCommandResponse'
        '400':
          description: >-
            Missing `Authorization` or malformed Bearer credentials return `invalid_authorization_header`; invalid
            request parameters return `invalid_request`. A syntactically valid credential with an invalid API key
            returns `401 unauthorized` 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 invalid_authorization_header`.
          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: >-
            Send JSON request bodies with `Content-Type: application/json`. The API rejects an explicitly supplied
            malformed or unsupported media type.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/MaskRecordingRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different method, path, query, content type, body, or
            `Operation-Id`. 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 for the applicable per-command, per-room, or per-app scope. The `Retry-After` response
            header gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/MaskRecordingRequestTooManyRequestsError'
        '500':
          description: >-
            An unexpected platform failure. Quote `support_id` to support; the technical cause and vendor event
            identifier are never exposed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
        '503':
          description: >-
            When an `Idempotency-Key` was supplied, the idempotency store is unavailable and the request was NOT
            processed; retry with the same key. An operation can document another `503` condition with different
            execution and retry guidance; follow the operation description and the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/MaskRecordingRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties: {}
  /v1/sessions/{uuid}/recordings/{recording_uuid}/unmask:
    post:
      operationId: unmaskRecording
      summary: Unmask (resume writing) the active recording
      description: |-
        **Rate limit: Per command** · **Burst:** 20 · **Refill:** 20 req/s

        Unmask the recording identified by `recording_uuid` to resume writing after mask. The
        recording continues uninterrupted. Calling unmask when not masked is harmless.

        Shares the `seek` bucket.

        Requires that exact recording to be active; returns `404 Not Found` if it is not
        in progress (the call is unaffected). A 202 response confirms admission.
      tags:
        - recording
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) identifier.'
          required: true
          schema:
            type: string
        - name: recording_uuid
          in: path
          required: true
          schema:
            type: string
            pattern: ^rec_[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. See [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for
            details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional key for safely retrying mutating requests. See
            [Idempotency](https://voice-platform.docs.buildwithfern.com/idempotency) for details.
          required: false
          schema:
            type: string
            pattern: ^[a-zA-Z0-9._-]+$
            maxLength: 128
        - name: Operation-Id
          in: header
          description: >-
            optional client-supplied lowercase RFC-4122 v4 UUID returned as operation_uuid; platform generates one when
            omitted; correlation metadata distinct from Idempotency-Key.
          required: false
          schema:
            type: string
            format: uuid
            pattern: ^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
      responses:
        '202':
          description: Command accepted for async execution
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AsyncCommandResponse'
        '400':
          description: >-
            Missing `Authorization` or malformed Bearer credentials return `invalid_authorization_header`; invalid
            request parameters return `invalid_request`. A syntactically valid credential with an invalid API key
            returns `401 unauthorized` 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 invalid_authorization_header`.
          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: >-
            Send JSON request bodies with `Content-Type: application/json`. The API rejects an explicitly supplied
            malformed or unsupported media type.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UnmaskRecordingRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different method, path, query, content type, body, or
            `Operation-Id`. 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 for the applicable per-command, per-room, or per-app scope. The `Retry-After` response
            header gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UnmaskRecordingRequestTooManyRequestsError'
        '500':
          description: >-
            An unexpected platform failure. Quote `support_id` to support; the technical cause and vendor event
            identifier are never exposed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
        '503':
          description: >-
            When an `Idempotency-Key` was supplied, the idempotency store is unavailable and the request was NOT
            processed; retry with the same key. An operation can document another `503` condition with different
            execution and retry guidance; follow the operation description and the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UnmaskRecordingRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties: {}
  /v1/sessions/{uuid}/playback/play:
    post:
      operationId: startAudioPlayback
      summary: Start audio playback
      description: |-
        **Rate limit: Per command** · **Burst:** 8 · **Refill:** 4 req/s

        Choose the tab for your audio source.

        <Tabs>
        <Tab title="Audio files">

        Play one WAV or MP3 file, or a playlist:

        ```json
        {
          "type": "files",
          "urls": [
            "https://media.example.com/greeting.mp3",
            "https://media.example.com/menu.wav"
          ]
        }
        ```

        The platform plays the URLs in order. Use `offset_ms` only with one
        file. For private files, use presigned HTTPS URLs that remain valid
        through playback. [Seek within playback](/api/playback/seek) is
        available only for files.

        </Tab>
        <Tab title="Live TTS">

        Start a pushed raw-audio stream:

        ```json
        {
          "type": "stream",
          "media_format": {
            "encoding": "pcm_s16le",
            "sample_rate": 24000
          }
        }
        ```

        The `202 Accepted` response includes a short-lived `upload_url`.
        Stream the TTS bytes in one HTTP request body, then close the body when
        the TTS stream ends:

        ```http
        PUT {upload_url}
        Content-Type: application/octet-stream

        <raw audio bytes>
        ```

        The audio must match `media_format`: signed little-endian PCM16 at 8,
        16, 24, or 48 kHz; or G.711 mu-law at 8 kHz.

        </Tab>
        <Tab title="Silence">

        Keep Session Playback active without an audio source:

        ```json
        {
          "type": "silence"
        }
        ```

        Silence continues until another playback replaces it, the session
        ends, or you [stop playback](/api/playback/stop).

        </Tab>
        </Tabs>

        An accepted request returns `202 Accepted` with `operation_uuid` and
        `status: in_progress`. New playback replaces active playback
        automatically. See [Playback lifecycle events](/api/playback#lifecycle-events)
        for completion and failure webhooks.
      tags:
        - playback
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) identifier.'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. See [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for
            details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional key for safely retrying mutating requests. See
            [Idempotency](https://voice-platform.docs.buildwithfern.com/idempotency) for details.
          required: false
          schema:
            type: string
            pattern: ^[a-zA-Z0-9._-]+$
            maxLength: 128
        - name: Operation-Id
          in: header
          description: >-
            optional client-supplied lowercase RFC-4122 v4 UUID returned as operation_uuid; platform generates one when
            omitted; correlation metadata distinct from Idempotency-Key.
          required: false
          schema:
            type: string
            format: uuid
            pattern: ^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
      responses:
        '202':
          description: Playback accepted.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Playback_startAudioPlayback_Response_202'
        '400':
          description: >-
            Missing `Authorization` or malformed Bearer credentials return `invalid_authorization_header`; invalid
            request parameters return `invalid_request`. A syntactically valid credential with an invalid API key
            returns `401 unauthorized` 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 invalid_authorization_header`.
          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: >-
            Send JSON request bodies with `Content-Type: application/json`. The API rejects an explicitly supplied
            malformed or unsupported media type.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StartAudioPlaybackRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different method, path, query, content type, body, or
            `Operation-Id`. 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 for the applicable per-command, per-room, or per-app scope. The `Retry-After` response
            header gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StartAudioPlaybackRequestTooManyRequestsError'
        '500':
          description: >-
            An unexpected platform failure. Quote `support_id` to support; the technical cause and vendor event
            identifier are never exposed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
        '502':
          description: The playback source is unavailable or unsupported.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PlaybackSourceErrorResponse'
        '503':
          description: Playback admission is temporarily unavailable; no new playback was admitted. Retry the request.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StartAudioPlaybackRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/SessionPlaybackRequest'
  /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. A 202 response confirms admission. Reuse the same optional `Operation-Id` header for the
        same command within 10 minutes; reusing it for another media command returns 409.
      tags:
        - playback
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) identifier.'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. See [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for
            details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional key for safely retrying mutating requests. See
            [Idempotency](https://voice-platform.docs.buildwithfern.com/idempotency) for details.
          required: false
          schema:
            type: string
            pattern: ^[a-zA-Z0-9._-]+$
            maxLength: 128
        - name: Operation-Id
          in: header
          description: >-
            optional client-supplied lowercase RFC-4122 v4 UUID returned as operation_uuid; platform generates one when
            omitted; correlation metadata distinct from Idempotency-Key.
          required: false
          schema:
            type: string
            format: uuid
            pattern: ^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
      responses:
        '202':
          description: Command accepted for async execution
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AsyncCommandResponse'
        '400':
          description: >-
            Missing `Authorization` or malformed Bearer credentials return `invalid_authorization_header`; invalid
            request parameters return `invalid_request`. A syntactically valid credential with an invalid API key
            returns `401 unauthorized` 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 invalid_authorization_header`.
          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: >-
            Send JSON request bodies with `Content-Type: application/json`. The API rejects an explicitly supplied
            malformed or unsupported media type.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PausePlaybackRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different method, path, query, content type, body, or
            `Operation-Id`. 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 for the applicable per-command, per-room, or per-app scope. The `Retry-After` response
            header gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PausePlaybackRequestTooManyRequestsError'
        '500':
          description: >-
            An unexpected platform failure. Quote `support_id` to support; the technical cause and vendor event
            identifier are never exposed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
        '503':
          description: >-
            When an `Idempotency-Key` was supplied, the idempotency store is unavailable and the request was NOT
            processed; retry with the same key. An operation can document another `503` condition with different
            execution and retry guidance; follow the operation description and the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PausePlaybackRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties: {}
  /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. A 202 response confirms admission. Reuse the same optional `Operation-Id` header for the
        same command within 10 minutes; reusing it for another media command returns 409.
      tags:
        - playback
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) identifier.'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. See [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for
            details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional key for safely retrying mutating requests. See
            [Idempotency](https://voice-platform.docs.buildwithfern.com/idempotency) for details.
          required: false
          schema:
            type: string
            pattern: ^[a-zA-Z0-9._-]+$
            maxLength: 128
        - name: Operation-Id
          in: header
          description: >-
            optional client-supplied lowercase RFC-4122 v4 UUID returned as operation_uuid; platform generates one when
            omitted; correlation metadata distinct from Idempotency-Key.
          required: false
          schema:
            type: string
            format: uuid
            pattern: ^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
      responses:
        '202':
          description: Command accepted for async execution
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AsyncCommandResponse'
        '400':
          description: >-
            Missing `Authorization` or malformed Bearer credentials return `invalid_authorization_header`; invalid
            request parameters return `invalid_request`. A syntactically valid credential with an invalid API key
            returns `401 unauthorized` 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 invalid_authorization_header`.
          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: >-
            Send JSON request bodies with `Content-Type: application/json`. The API rejects an explicitly supplied
            malformed or unsupported media type.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ResumePlaybackRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different method, path, query, content type, body, or
            `Operation-Id`. 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 for the applicable per-command, per-room, or per-app scope. The `Retry-After` response
            header gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ResumePlaybackRequestTooManyRequestsError'
        '500':
          description: >-
            An unexpected platform failure. Quote `support_id` to support; the technical cause and vendor event
            identifier are never exposed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
        '503':
          description: >-
            When an `Idempotency-Key` was supplied, the idempotency store is unavailable and the request was NOT
            processed; retry with the same key. An operation can document another `503` condition with different
            execution and retry guidance; follow the operation description and the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ResumePlaybackRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties: {}
  /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. A 202 response confirms admission. Reuse the same optional `Operation-Id` header
        for the same command within 10 minutes; reusing it for another media command returns 409.
      tags:
        - playback
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) identifier.'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. See [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for
            details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional key for safely retrying mutating requests. See
            [Idempotency](https://voice-platform.docs.buildwithfern.com/idempotency) for details.
          required: false
          schema:
            type: string
            pattern: ^[a-zA-Z0-9._-]+$
            maxLength: 128
        - name: Operation-Id
          in: header
          description: >-
            optional client-supplied lowercase RFC-4122 v4 UUID returned as operation_uuid; platform generates one when
            omitted; correlation metadata distinct from Idempotency-Key.
          required: false
          schema:
            type: string
            format: uuid
            pattern: ^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
      responses:
        '202':
          description: Command accepted for async execution
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AsyncCommandResponse'
        '400':
          description: >-
            Missing `Authorization` or malformed Bearer credentials return `invalid_authorization_header`; invalid
            request parameters return `invalid_request`. A syntactically valid credential with an invalid API key
            returns `401 unauthorized` 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 invalid_authorization_header`.
          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: >-
            Send JSON request bodies with `Content-Type: application/json`. The API rejects an explicitly supplied
            malformed or unsupported media type.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SeekWithinPlaybackRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different method, path, query, content type, body, or
            `Operation-Id`. 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 for the applicable per-command, per-room, or per-app scope. The `Retry-After` response
            header gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SeekWithinPlaybackRequestTooManyRequestsError'
        '500':
          description: >-
            An unexpected platform failure. Quote `support_id` to support; the technical cause and vendor event
            identifier are never exposed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
        '503':
          description: >-
            When an `Idempotency-Key` was supplied, the idempotency store is unavailable and the request was NOT
            processed; retry with the same key. An operation can document another `503` condition with different
            execution and retry guidance; follow the operation description and the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SeekWithinPlaybackRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties:
                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/restart:
    post:
      operationId: restartPlayback
      summary: Restart playback
      description: |-
        **Rate limit: Per command** · **Burst:** 20 · **Refill:** 20 req/s

        Restart playback from the beginning. A 202 response confirms admission.

        If no playback is active the command is rejected and `playback.failed`
        `{reason:"no_active_playback"}` fires instead.

        See [Playback lifecycle events](/api/playback#lifecycle-events) for complete payload schemas and examples.
      tags:
        - playback
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) identifier.'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. See [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for
            details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional key for safely retrying mutating requests. See
            [Idempotency](https://voice-platform.docs.buildwithfern.com/idempotency) for details.
          required: false
          schema:
            type: string
            pattern: ^[a-zA-Z0-9._-]+$
            maxLength: 128
        - name: Operation-Id
          in: header
          description: >-
            optional client-supplied lowercase RFC-4122 v4 UUID returned as operation_uuid; platform generates one when
            omitted; correlation metadata distinct from Idempotency-Key.
          required: false
          schema:
            type: string
            format: uuid
            pattern: ^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
      responses:
        '202':
          description: Command accepted for async execution
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AsyncCommandResponse'
        '400':
          description: >-
            Missing `Authorization` or malformed Bearer credentials return `invalid_authorization_header`; invalid
            request parameters return `invalid_request`. A syntactically valid credential with an invalid API key
            returns `401 unauthorized` 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 invalid_authorization_header`.
          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: >-
            Send JSON request bodies with `Content-Type: application/json`. The API rejects an explicitly supplied
            malformed or unsupported media type.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RestartPlaybackRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different method, path, query, content type, body, or
            `Operation-Id`. 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 for the applicable per-command, per-room, or per-app scope. The `Retry-After` response
            header gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RestartPlaybackRequestTooManyRequestsError'
        '500':
          description: >-
            An unexpected platform failure. Quote `support_id` to support; the technical cause and vendor event
            identifier are never exposed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
        '503':
          description: >-
            When an `Idempotency-Key` was supplied, the idempotency store is unavailable and the request was NOT
            processed; retry with the same key. An operation can document another `503` condition with different
            execution and retry guidance; follow the operation description and the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RestartPlaybackRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties: {}
  /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)

        See [Playback lifecycle events](/api/playback#lifecycle-events) for complete payload schemas and examples.
      tags:
        - playback
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) identifier.'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. See [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for
            details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional key for safely retrying mutating requests. See
            [Idempotency](https://voice-platform.docs.buildwithfern.com/idempotency) for details.
          required: false
          schema:
            type: string
            pattern: ^[a-zA-Z0-9._-]+$
            maxLength: 128
        - name: Operation-Id
          in: header
          description: >-
            optional client-supplied lowercase RFC-4122 v4 UUID returned as operation_uuid; platform generates one when
            omitted; correlation metadata distinct from Idempotency-Key.
          required: false
          schema:
            type: string
            format: uuid
            pattern: ^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
      responses:
        '202':
          description: Command accepted for async execution
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AsyncCommandResponse'
        '400':
          description: >-
            Missing `Authorization` or malformed Bearer credentials return `invalid_authorization_header`; invalid
            request parameters return `invalid_request`. A syntactically valid credential with an invalid API key
            returns `401 unauthorized` 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 invalid_authorization_header`.
          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: >-
            Send JSON request bodies with `Content-Type: application/json`. The API rejects an explicitly supplied
            malformed or unsupported media type.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StopPlaybackRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different method, path, query, content type, body, or
            `Operation-Id`. 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 for the applicable per-command, per-room, or per-app scope. The `Retry-After` response
            header gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StopPlaybackRequestTooManyRequestsError'
        '500':
          description: >-
            An unexpected platform failure. Quote `support_id` to support; the technical cause and vendor event
            identifier are never exposed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
        '503':
          description: Playback stop unavailable; no stop was dispatched.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StopPlaybackRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties: {}
  /v1/media-streams/{operation_uuid}/source:
    post:
      operationId: uploadPlaybackAudio
      summary: Upload pushed playback audio
      description: >-
        Send the raw audio body for a previously accepted Session Playback with `type: push`. Use the URL, method, and
        headers returned in the Playback response, and also send the application's normal `Authorization: Bearer
        <app_uuid>:<api_key>` header. The operation must belong to the authenticated application, remain active, and the
        one-shot request must be opened before `ingest.expires_at`; an accepted request may continue streaming
        afterward. Send exactly one unframed stream and close the request body at EOF. A `204` means the complete
        request body was accepted; playback completion is reported separately by lifecycle webhooks.
      tags:
        - playback
      parameters:
        - name: operation_uuid
          in: path
          description: Operation UUID returned by the accepted push Playback command.
          required: true
          schema:
            type: string
            format: uuid
            pattern: ^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. See [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for
            details.
          required: true
          schema:
            type: string
      responses:
        '204':
          description: The complete audio body was accepted.
          content:
            application/json:
              schema:
                type: object
                properties: {}
        '400':
          description: >-
            Missing `Authorization` or malformed Bearer credentials return `invalid_authorization_header`; invalid
            request parameters return `invalid_request`. A syntactically valid credential with an invalid API key
            returns `401 unauthorized` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UploadPlaybackAudioRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400 invalid_authorization_header`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UploadPlaybackAudioRequestUnauthorizedError'
        '404':
          description: The requested resource was not found or is not owned by the authenticated app.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UploadPlaybackAudioRequestNotFoundError'
        '409':
          description: The ingest target is expired, already used, or no longer active.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UploadPlaybackAudioRequestConflictError'
        '415':
          description: The request must use `application/octet-stream`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UploadPlaybackAudioRequestUnsupportedMediaTypeError'
        '429':
          description: >-
            Rate limit exceeded for the applicable per-command, per-room, or per-app scope. The `Retry-After` response
            header gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UploadPlaybackAudioRequestTooManyRequestsError'
        '503':
          description: Audio ingest is temporarily unavailable.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UploadPlaybackAudioRequestServiceUnavailableError'
      requestBody:
        content:
          application/octet-stream:
            schema:
              type: string
              format: binary
  /v1/sessions/{uuid}/dtmf/collect:
    post:
      operationId: playPromptAndCollectDTMFDigits
      summary: Collect DTMF input with optional playback
      description: >-
        **Rate limit: Per command** · **Burst:** 4 · **Refill:** 0.8 req/s


        Collect a complete DTMF response from the caller and optionally play audio prompts first. The operation groups
        the caller's keys and applies the configured digit-count, timeout, terminator, and regular-expression validation
        rules.


        The platform validates and prepares every prompt URL before admitting the command. An unavailable prompt returns
        a synchronous HTTP error and does not trigger a webhook. A `202 Accepted` response means that the command was
        queued. The application stores its `operation_uuid` and matches it to the same field in the terminal
        `digits.collected` event.


        The platform runs exactly one prompt-and-collect cycle and emits one `digits.collected` event with the collected
        value and outcome `status`. It does not retry the cycle. The application inspects `status` and submits another
        command when needed, such as a command with an invalid-PIN prompt after `status: invalid`.


        The platform also emits a `dtmf.received` event immediately for every key press, whether or not a collection is
        active. Each event contains one key and its `duration_ms`; it does not group digits or apply collection rules.
        These events continue during a collection.


        **Triggered webhook:** `digits.collected`.


        This POST and its cancel DELETE each use a separate rate-limit bucket with the same configuration.


        See [Keypad input lifecycle events](/api/keypad-input#lifecycle-events) for complete payload schemas and
        examples.
      tags:
        - keypadInput
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) identifier.'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. See [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for
            details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional key for safely retrying mutating requests. See
            [Idempotency](https://voice-platform.docs.buildwithfern.com/idempotency) for details.
          required: false
          schema:
            type: string
            pattern: ^[a-zA-Z0-9._-]+$
            maxLength: 128
        - name: Operation-Id
          in: header
          description: >-
            optional client-supplied lowercase RFC-4122 v4 UUID returned as operation_uuid; platform generates one when
            omitted; correlation metadata distinct from Idempotency-Key.
          required: false
          schema:
            type: string
            format: uuid
            pattern: ^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
      responses:
        '202':
          description: Command accepted for async execution
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AsyncCommandResponse'
        '400':
          description: >-
            Missing `Authorization` or malformed Bearer credentials return `invalid_authorization_header`; invalid
            request parameters return `invalid_request`. A syntactically valid credential with an invalid API key
            returns `401 unauthorized` 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 invalid_authorization_header`.
          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: >-
            Send JSON request bodies with `Content-Type: application/json`. The API rejects an explicitly supplied
            malformed or unsupported media type.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PlayPromptAndCollectDTMFDigitsRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different method, path, query, content type, body, or
            `Operation-Id`. 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 for the applicable per-command, per-room, or per-app scope. The `Retry-After` response
            header gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PlayPromptAndCollectDTMFDigitsRequestTooManyRequestsError'
        '500':
          description: >-
            An unexpected platform failure. Quote `support_id` to support; the technical cause and vendor event
            identifier are never exposed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
        '502':
          description: The prompt source is unavailable, so the command was not accepted.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PlaybackSourceErrorResponse'
        '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:
                between_digits_timeout_ms:
                  type: integer
                  minimum: 100
                  maximum: 10000
                  description: Milliseconds to wait between digits before timing out.
                first_digit_timeout_ms:
                  type: integer
                  minimum: 1000
                  maximum: 300000
                  description: Milliseconds to wait for the first digit before timing out.
                max_digits:
                  type: integer
                  minimum: 1
                  maximum: 128
                  description: Maximum digits to collect. Must be >= min_digits.
                min_digits:
                  type: integer
                  minimum: 0
                  maximum: 128
                prompt_files:
                  type: array
                  items:
                    type: string
                    format: uri
                    pattern: ^https?://
                    maxLength: 2048
                  description: Optional HTTP/HTTPS WAV or MP3 URLs to play as the prompt before collecting digits.
                terminators:
                  type: array
                  items:
                    $ref: >-
                      #/components/schemas/V1SessionsUuidDtmfCollectPostRequestBodyContentApplicationJsonSchemaTerminatorsItems
                  description: 'DTMF terminator characters. Only # and * allowed.'
                validation:
                  $ref: '#/components/schemas/V1SessionsUuidDtmfCollectPostRequestBodyContentApplicationJsonSchemaValidation'
                  description: Optional input validation.
              required:
                - between_digits_timeout_ms
                - first_digit_timeout_ms
                - max_digits
                - min_digits
                - terminators
    delete:
      operationId: cancelPlayPromptAndCollectDTMFDigits
      summary: Cancel in-progress DTMF collection
      description: >-
        **Rate limit: Per command** · **Burst:** 4 · **Refill:** 0.8 req/s


        Cancel the current DTMF collection for this session. If no collection is in progress, the request is accepted
        and has no effect.


        If a collection is in progress, cancellation proceeds in these stages:


        1. The `202` response accepts the cancellation request.

        2. Prompt playback stops promptly.

        3. The collection phase ends according to its existing timers.

        4. The platform emits the terminal `digits.collected` webhook with `status: cancelled`.


        The `202` response does not mean that the terminal webhook is ready.


        Input entered after cancellation is discarded from later collections. It is reported only by the cancelled
        command's terminal `digits.collected` event.


        This DELETE uses its own rate-limit bucket. The corresponding POST uses the same configuration in a separate
        bucket.


        See [Keypad input lifecycle events](/api/keypad-input#lifecycle-events) for complete payload schemas and
        examples.
      tags:
        - keypadInput
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) identifier.'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. See [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for
            details.
          required: true
          schema:
            type: string
        - name: Operation-Id
          in: header
          description: >-
            optional client-supplied lowercase RFC-4122 v4 UUID returned as operation_uuid; platform generates one when
            omitted; correlation metadata distinct from Idempotency-Key.
          required: false
          schema:
            type: string
            format: uuid
            pattern: ^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
      responses:
        '202':
          description: Cancellation accepted.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Keypad Input_cancelPlayPromptAndCollectDTMFDigits_Response_202'
        '400':
          description: >-
            Missing `Authorization` or malformed Bearer credentials return `invalid_authorization_header`; invalid
            request parameters return `invalid_request`. A syntactically valid credential with an invalid API key
            returns `401 unauthorized` 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 invalid_authorization_header`.
          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 for the applicable per-command, per-room, or per-app scope. The `Retry-After` response
            header gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CancelPlayPromptAndCollectDTMFDigitsRequestTooManyRequestsError'
        '500':
          description: >-
            An unexpected platform failure. Quote `support_id` to support; the technical cause and vendor event
            identifier are never exposed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
  /v1/sessions/{uuid}/dtmf/send:
    post:
      operationId: sendDTMFDigits
      summary: Send DTMF sequence
      description: >-
        **Rate limit: Per command** · **Burst:** 20 · **Refill:** 20 req/s


        Send an ordered sequence of DTMF key presses and waits to the remote party during an answered phone session.
        Each action specifies its key-press duration or wait. The platform preserves action order, but a
        `wait.duration_ms` value is a minimum delay and the next action might start later.


        The platform accepts only one active sequence per session. It does not accept this command for ringing calls or
        WebSocket sessions created with `POST /v1/sessions:connectWebsocket`.


        A `202` response confirms that the platform durably admitted the sequence. It does not confirm that the remote
        party handled the keys, and the platform does not emit an acceptance webhook.


        See [Keypad input lifecycle events](/api/keypad-input#lifecycle-events) for complete payload schemas and
        examples.
      tags:
        - keypadInput
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) identifier.'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. See [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for
            details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional key for safely retrying mutating requests. See
            [Idempotency](https://voice-platform.docs.buildwithfern.com/idempotency) for details.
          required: false
          schema:
            type: string
            pattern: ^[a-zA-Z0-9._-]+$
            maxLength: 128
        - name: Operation-Id
          in: header
          description: >-
            optional client-supplied lowercase RFC-4122 v4 UUID returned as operation_uuid; platform generates one when
            omitted; correlation metadata distinct from Idempotency-Key.
          required: false
          schema:
            type: string
            format: uuid
            pattern: ^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
      responses:
        '202':
          description: Command accepted for async execution
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AsyncCommandResponse'
        '400':
          description: >-
            Missing `Authorization` or malformed Bearer credentials return `invalid_authorization_header`; invalid
            request parameters return `invalid_request`. A syntactically valid credential with an invalid API key
            returns `401 unauthorized` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SendDTMFDigitsRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400 invalid_authorization_header`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SendDTMFDigitsRequestUnauthorizedError'
        '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/SendDTMFDigitsRequestNotFoundError'
        '409':
          description: >-
            The session is terminating, has not been answered, has no remote phone party, or already has an outbound
            DTMF sequence in progress.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SendDTMFDigitsRequestConflictError'
        '413':
          description: Request body exceeds the endpoint's size limit.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SendDTMFDigitsRequestContentTooLargeError'
        '415':
          description: >-
            Send JSON request bodies with `Content-Type: application/json`. The API rejects an explicitly supplied
            malformed or unsupported media type.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SendDTMFDigitsRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different method, path, query, content type, body, or
            `Operation-Id`. A key maps to one request; use a new key. See the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SendDTMFDigitsRequestUnprocessableEntityError'
        '429':
          description: >-
            Rate limit exceeded for the applicable per-command, per-room, or per-app scope. The `Retry-After` response
            header gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SendDTMFDigitsRequestTooManyRequestsError'
        '500':
          description: >-
            An unexpected platform failure. Quote `support_id` to support; the technical cause and vendor event
            identifier are never exposed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
        '503':
          description: >-
            When an `Idempotency-Key` was supplied, the idempotency store is unavailable and the request was NOT
            processed; retry with the same key. An operation can document another `503` condition with different
            execution and retry guidance; follow the operation description and the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SendDTMFDigitsRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties:
                sequence:
                  type: array
                  items:
                    $ref: >-
                      #/components/schemas/V1SessionsUuidDtmfSendPostRequestBodyContentApplicationJsonSchemaSequenceItems
                  description: >-
                    Ordered key and wait actions. Waits may appear anywhere and consecutive waits are allowed. The total
                    nominal duration may not exceed ten minutes, and the sequence must include at least one key action.
              required:
                - sequence
    delete:
      operationId: cancelDTMFSend
      summary: Cancel outbound DTMF sequence
      description: >-
        **Rate limit: Per command** · **Burst:** 20 · **Refill:** 20 req/s


        Cancel the active outbound DTMF sequence for the session. Before returning `202`, the platform deletes the
        remaining sequence plan so that it cannot schedule another key or wait action. A key whose transmission has
        already started might still finish.


        If no sequence is active, the platform accepts the request without taking further action. The `202` response
        acknowledges the cancellation request. The platform does not emit a terminal webhook.


        See [Keypad input lifecycle events](/api/keypad-input#lifecycle-events) for complete payload schemas and
        examples.
      tags:
        - keypadInput
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) identifier.'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. See [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for
            details.
          required: true
          schema:
            type: string
        - name: Operation-Id
          in: header
          description: >-
            optional client-supplied lowercase RFC-4122 v4 UUID returned as operation_uuid; platform generates one when
            omitted; correlation metadata distinct from Idempotency-Key.
          required: false
          schema:
            type: string
            format: uuid
            pattern: ^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
      responses:
        '202':
          description: Cancellation accepted.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Keypad Input_cancelDTMFSend_Response_202'
        '400':
          description: >-
            Missing `Authorization` or malformed Bearer credentials return `invalid_authorization_header`; invalid
            request parameters return `invalid_request`. A syntactically valid credential with an invalid API key
            returns `401 unauthorized` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CancelDTMFSendRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400 invalid_authorization_header`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CancelDTMFSendRequestUnauthorizedError'
        '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/CancelDTMFSendRequestNotFoundError'
        '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/CancelDTMFSendRequestConflictError'
        '429':
          description: >-
            Rate limit exceeded for the applicable per-command, per-room, or per-app scope. The `Retry-After` response
            header gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CancelDTMFSendRequestTooManyRequestsError'
        '500':
          description: >-
            An unexpected platform failure. Quote `support_id` to support; the technical cause and vendor event
            identifier are never exposed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
        '503':
          description: DTMF scheduler state is unavailable; no cancellation was applied.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CancelDTMFSendRequestServiceUnavailableError'
  /v1/sessions/{uuid}/payment/card/collect:
    post:
      operationId: collectSecurePaymentCard
      summary: Collect a payment card
      description: >-
        Start one isolated secure collection workflow for the Session. The Gateway never receives, stores, logs, or
        returns the collected card digits. Card collection accepts 12–19 digits and applies Luhn validation inside the
        trusted payment path; security-code collection accepts exactly three digits. A `202` response is only admission.
        The terminal result is delivered as a sanitized payment webhook.


        See [Payment lifecycle events](/api/payments#lifecycle-events) for complete payload schemas and examples.
      tags:
        - payments
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) identifier.'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. See [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for
            details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional key for safely retrying mutating requests. See
            [Idempotency](https://voice-platform.docs.buildwithfern.com/idempotency) for details.
          required: false
          schema:
            type: string
            pattern: ^[a-zA-Z0-9._-]+$
            maxLength: 128
        - name: Operation-Id
          in: header
          description: >-
            optional client-supplied lowercase RFC-4122 v4 UUID returned as operation_uuid; platform generates one when
            omitted; correlation metadata distinct from Idempotency-Key.
          required: false
          schema:
            type: string
            format: uuid
            pattern: ^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
      responses:
        '202':
          description: Command accepted for async execution
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AsyncCommandResponse'
        '400':
          description: >-
            Missing `Authorization` or malformed Bearer credentials return `invalid_authorization_header`; invalid
            request parameters return `invalid_request`. A syntactically valid credential with an invalid API key
            returns `401 unauthorized` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CollectSecurePaymentCardRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400 invalid_authorization_header`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CollectSecurePaymentCardRequestUnauthorizedError'
        '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/CollectSecurePaymentCardRequestNotFoundError'
        '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/CollectSecurePaymentCardRequestConflictError'
        '413':
          description: Request body exceeds the endpoint's size limit.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CollectSecurePaymentCardRequestContentTooLargeError'
        '415':
          description: >-
            Send JSON request bodies with `Content-Type: application/json`. The API rejects an explicitly supplied
            malformed or unsupported media type.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CollectSecurePaymentCardRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different method, path, query, content type, body, or
            `Operation-Id`. A key maps to one request; use a new key. See the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CollectSecurePaymentCardRequestUnprocessableEntityError'
        '429':
          description: >-
            Rate limit exceeded for the applicable per-command, per-room, or per-app scope. The `Retry-After` response
            header gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CollectSecurePaymentCardRequestTooManyRequestsError'
        '500':
          description: >-
            An unexpected platform failure. Quote `support_id` to support; the technical cause and vendor event
            identifier are never exposed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
        '502':
          description: A prompt source is unavailable, so secure collection was not accepted.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PlaybackSourceErrorResponse'
        '503':
          description: >-
            When an `Idempotency-Key` was supplied, the idempotency store is unavailable and the request was NOT
            processed; retry with the same key. An operation can document another `503` condition with different
            execution and retry guidance; follow the operation description and the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CollectSecurePaymentCardRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties:
                between_digits_timeout_ms:
                  type: integer
                  minimum: 100
                  maximum: 10000
                  description: Milliseconds to wait between digits.
                first_digit_timeout_ms:
                  type: integer
                  minimum: 1000
                  maximum: 300000
                  description: Milliseconds to wait for the first digit.
                prompt_files:
                  type: array
                  items:
                    type: string
                    format: uri
                    pattern: ^https?://
                    maxLength: 2048
                  description: Optional HTTP/HTTPS WAV or MP3 prompts played before the secure collection window opens.
                terminators:
                  type: array
                  items:
                    $ref: >-
                      #/components/schemas/V1SessionsUuidPaymentCardCollectPostRequestBodyContentApplicationJsonSchemaTerminatorsItems
                  description: Distinct DTMF terminators. An empty array collects to the fixed secure length or timeout.
              required:
                - between_digits_timeout_ms
                - first_digit_timeout_ms
                - terminators
  /v1/sessions/{uuid}/payment/cvv/collect:
    post:
      operationId: collectSecurePaymentCVV
      summary: Collect CVV
      description: >-
        Start one isolated secure collection workflow for the Session. The Gateway never receives, stores, logs, or
        returns the collected card digits. Card collection accepts 12–19 digits and applies Luhn validation inside the
        trusted payment path; security-code collection accepts exactly three digits. A `202` response is only admission.
        The terminal result is delivered as a sanitized payment webhook.


        See [Payment lifecycle events](/api/payments#lifecycle-events) for complete payload schemas and examples.
      tags:
        - payments
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) identifier.'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. See [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for
            details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: >-
            Optional key for safely retrying mutating requests. See
            [Idempotency](https://voice-platform.docs.buildwithfern.com/idempotency) for details.
          required: false
          schema:
            type: string
            pattern: ^[a-zA-Z0-9._-]+$
            maxLength: 128
        - name: Operation-Id
          in: header
          description: >-
            optional client-supplied lowercase RFC-4122 v4 UUID returned as operation_uuid; platform generates one when
            omitted; correlation metadata distinct from Idempotency-Key.
          required: false
          schema:
            type: string
            format: uuid
            pattern: ^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
      responses:
        '202':
          description: Command accepted for async execution
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AsyncCommandResponse'
        '400':
          description: >-
            Missing `Authorization` or malformed Bearer credentials return `invalid_authorization_header`; invalid
            request parameters return `invalid_request`. A syntactically valid credential with an invalid API key
            returns `401 unauthorized` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CollectSecurePaymentCVVRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400 invalid_authorization_header`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CollectSecurePaymentCVVRequestUnauthorizedError'
        '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/CollectSecurePaymentCVVRequestNotFoundError'
        '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/CollectSecurePaymentCVVRequestConflictError'
        '413':
          description: Request body exceeds the endpoint's size limit.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CollectSecurePaymentCVVRequestContentTooLargeError'
        '415':
          description: >-
            Send JSON request bodies with `Content-Type: application/json`. The API rejects an explicitly supplied
            malformed or unsupported media type.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CollectSecurePaymentCVVRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different method, path, query, content type, body, or
            `Operation-Id`. A key maps to one request; use a new key. See the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CollectSecurePaymentCVVRequestUnprocessableEntityError'
        '429':
          description: >-
            Rate limit exceeded for the applicable per-command, per-room, or per-app scope. The `Retry-After` response
            header gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CollectSecurePaymentCVVRequestTooManyRequestsError'
        '500':
          description: >-
            An unexpected platform failure. Quote `support_id` to support; the technical cause and vendor event
            identifier are never exposed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
        '502':
          description: A prompt source is unavailable, so secure collection was not accepted.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PlaybackSourceErrorResponse'
        '503':
          description: >-
            When an `Idempotency-Key` was supplied, the idempotency store is unavailable and the request was NOT
            processed; retry with the same key. An operation can document another `503` condition with different
            execution and retry guidance; follow the operation description and the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CollectSecurePaymentCVVRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties:
                between_digits_timeout_ms:
                  type: integer
                  minimum: 100
                  maximum: 10000
                  description: Milliseconds to wait between digits.
                first_digit_timeout_ms:
                  type: integer
                  minimum: 1000
                  maximum: 300000
                  description: Milliseconds to wait for the first digit.
                prompt_files:
                  type: array
                  items:
                    type: string
                    format: uri
                    pattern: ^https?://
                    maxLength: 2048
                  description: Optional HTTP/HTTPS WAV or MP3 prompts played before the secure collection window opens.
                terminators:
                  type: array
                  items:
                    $ref: >-
                      #/components/schemas/V1SessionsUuidPaymentCvvCollectPostRequestBodyContentApplicationJsonSchemaTerminatorsItems
                  description: Distinct DTMF terminators. An empty array collects to the fixed secure length or timeout.
              required:
                - between_digits_timeout_ms
                - first_digit_timeout_ms
                - terminators
  /v1/sessions/{uuid}/payment/charges:
    post:
      operationId: createSecurePaymentCharge
      summary: Create a charge
      description: >-
        Create a durable charge attempt from opaque card and security-code references. `Idempotency-Key` is required so
        charge admission can be replayed safely. The requested Nedarim terminal must be present in the authenticated
        application's operator-managed terminal allowlist; an unbound terminal is rejected before charge admission. The
        idempotency record stores a fingerprint of validated non-sensitive charge fields and the sanitized HTTP result,
        not the request body, card digits, or security code. A charge can be attempted only while the Session remains
        connected. After disconnect, the call-scoped card and security-code references are no longer usable. The Gateway
        stores only safe metadata and never receives card digits, a security code, provider credentials, or raw provider
        details. A provider timeout or uncertain submission is terminally reported as `indeterminate` and is never
        automatically submitted again.


        See [Payment lifecycle events](/api/payments#lifecycle-events) for complete payload schemas and examples.
      tags:
        - payments
      parameters:
        - name: uuid
          in: path
          description: '[Session](/api/sessions) identifier.'
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. See [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for
            details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          description: Required key used to make charge admission safely replayable.
          required: true
          schema:
            type: string
            pattern: ^[a-zA-Z0-9._-]+$
            maxLength: 128
        - name: Operation-Id
          in: header
          description: >-
            optional client-supplied lowercase RFC-4122 v4 UUID returned as operation_uuid; platform generates one when
            omitted; correlation metadata distinct from Idempotency-Key.
          required: false
          schema:
            type: string
            format: uuid
            pattern: ^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
      responses:
        '202':
          description: Command accepted for async execution
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AsyncCommandResponse'
        '400':
          description: >-
            Missing `Authorization` or malformed Bearer credentials return `invalid_authorization_header`; invalid
            request parameters return `invalid_request`. A syntactically valid credential with an invalid API key
            returns `401 unauthorized` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateSecurePaymentChargeRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400 invalid_authorization_header`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateSecurePaymentChargeRequestUnauthorizedError'
        '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/CreateSecurePaymentChargeRequestForbiddenError'
        '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/CreateSecurePaymentChargeRequestNotFoundError'
        '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/CreateSecurePaymentChargeRequestConflictError'
        '413':
          description: Request body exceeds the endpoint's size limit.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateSecurePaymentChargeRequestContentTooLargeError'
        '415':
          description: >-
            Send JSON request bodies with `Content-Type: application/json`. The API rejects an explicitly supplied
            malformed or unsupported media type.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateSecurePaymentChargeRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The `Idempotency-Key` was reused with a different method, path, query, content type, body, or
            `Operation-Id`. A key maps to one request; use a new key. See the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateSecurePaymentChargeRequestUnprocessableEntityError'
        '429':
          description: >-
            Rate limit exceeded for the applicable per-command, per-room, or per-app scope. The `Retry-After` response
            header gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateSecurePaymentChargeRequestTooManyRequestsError'
        '500':
          description: >-
            An unexpected platform failure. Quote `support_id` to support; the technical cause and vendor event
            identifier are never exposed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
        '503':
          description: >-
            When an `Idempotency-Key` was supplied, the idempotency store is unavailable and the request was NOT
            processed; retry with the same key. An operation can document another `503` condition with different
            execution and retry guidance; follow the operation description and the Idempotency guide.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateSecurePaymentChargeRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties:
                amount:
                  type: integer
                  minimum: 1
                  maximum: 999999999
                  description: Charge amount in the currency's smallest unit.
                card_uuid:
                  type: string
                  pattern: ^card_[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
                  description: Opaque card reference returned by `payment.card.collected`.
                currency:
                  $ref: '#/components/schemas/V1SessionsUuidPaymentChargesPostRequestBodyContentApplicationJsonSchemaCurrency'
                cvv_uuid:
                  type: string
                  pattern: ^cvv_[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
                  description: Opaque CVV reference returned by `payment.cvv.collected`.
                exp_month:
                  type: integer
                  minimum: 1
                  maximum: 12
                exp_year:
                  type: integer
                  minimum: 2000
                  maximum: 9999
                provider:
                  $ref: '#/components/schemas/V1SessionsUuidPaymentChargesPostRequestBodyContentApplicationJsonSchemaProvider'
                terminal_number:
                  type: string
                  pattern: ^[0-9]{7}$
                  description: >-
                    Seven-digit Nedarim Mosad terminal number for this charge. Operators must bind the terminal to the
                    authenticated application before it can be used.
              required:
                - amount
                - card_uuid
                - currency
                - cvv_uuid
                - exp_month
                - exp_year
                - provider
                - terminal_number
  /v1/messages:
    get:
      operationId: listMessages
      summary: List messages
      description: >-
        List messages owned by the authenticated application, newest first. The response includes messages retained by
        the platform and never includes another application's messages. Use message webhooks to receive status updates.


        See [Message lifecycle events](/api/messages#lifecycle-events) for complete payload schemas and examples.
      tags:
        - messages
      parameters:
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. See [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for
            details.
          required: true
          schema:
            type: string
      responses:
        '200':
          description: Messages owned by the authenticated application.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Messages_listMessages_Response_200'
        '400':
          description: >-
            Missing `Authorization` or malformed Bearer credentials return `invalid_authorization_header`; invalid
            request parameters return `invalid_request`. A syntactically valid credential with an invalid API key
            returns `401 unauthorized` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ListMessagesRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400 invalid_authorization_header`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ListMessagesRequestUnauthorizedError'
        '413':
          description: The complete retained message list exceeds the system result ceiling.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ListMessagesRequestContentTooLargeError'
        '500':
          description: >-
            An unexpected platform failure. Quote `support_id` to support; the technical cause and vendor event
            identifier are never exposed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
        '503':
          description: Message storage is temporarily unavailable.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ListMessagesRequestServiceUnavailableError'
    post:
      operationId: createMessage
      summary: Send an outbound SMS message
      description: >-
        **Tip: Due to legal requirements, contact us to approve your outbound sender identity.**


        Send one outbound SMS synchronously to the configured provider. Outbound SMS destinations are limited to Israel
        (`+972`).


        A `202` response confirms that the provider accepted the message into its queue. It does not confirm carrier
        handoff or recipient delivery.


        Track message progress through these webhooks:


        - `message.queued`: The provider accepted the message into its queue.

        - `message.sent`: The provider reported that it sent the message onward. This intermediate event might be
        omitted.

        - `message.delivery_status`: Recipient delivery succeeded, failed conclusively, or remained unknown when
        monitoring ended.


        See [Message lifecycle events](/api/messages#lifecycle-events) for complete payload schemas and examples.
      tags:
        - smsMessages
      parameters:
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. See [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for
            details.
          required: true
          schema:
            type: string
        - name: Idempotency-Key
          in: header
          required: true
          schema:
            type: string
            pattern: ^[A-Za-z0-9._-]{1,128}$
      responses:
        '202':
          description: The provider accepted the SMS into its queue.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SMS Messages_createMessage_Response_202'
        '400':
          description: >-
            Missing `Authorization` or malformed Bearer credentials return `invalid_authorization_header`; invalid
            request parameters return `invalid_request`. A syntactically valid credential with an invalid API key
            returns `401 unauthorized` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateMessageRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400 invalid_authorization_header`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateMessageRequestUnauthorizedError'
        '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/CreateMessageRequestForbiddenError'
        '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/CreateMessageRequestConflictError'
        '413':
          description: Request body exceeds the endpoint's size limit.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateMessageRequestContentTooLargeError'
        '415':
          description: >-
            Send JSON request bodies with `Content-Type: application/json`. The API rejects an explicitly supplied
            malformed or unsupported media type.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateMessageRequestUnsupportedMediaTypeError'
        '422':
          description: >-
            The request body is invalid, the destination country is not enabled for Messages, or the `Idempotency-Key`
            was reused with a different request body.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateMessageRequestUnprocessableEntityError'
        '429':
          description: >-
            Rate limit exceeded for the applicable per-command, per-room, or per-app scope. The `Retry-After` response
            header gives the integer seconds to wait before retrying.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateMessageRequestTooManyRequestsError'
        '500':
          description: >-
            An unexpected platform failure. Quote `support_id` to support; the technical cause and vendor event
            identifier are never exposed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
        '503':
          description: Message submission is temporarily unavailable. Retry only with the same Idempotency-Key.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateMessageRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties:
                channel:
                  $ref: '#/components/schemas/V1MessagesPostRequestBodyContentApplicationJsonSchemaChannel'
                content:
                  $ref: '#/components/schemas/V1MessagesPostRequestBodyContentApplicationJsonSchemaContent'
                from:
                  type: string
                to:
                  type: string
                  pattern: ^\+[1-9]\d{1,14}$
                  description: Message destination in canonical E.164 format. Only Israeli destinations (`+972`) are supported.
              required:
                - channel
                - content
                - from
                - to
  /v1/messages/{message_uuid}:
    get:
      operationId: getMessageStatus
      summary: Get SMS message status
      description: |-
        **Tip: Use message webhooks for status updates.**

        Use this endpoint to retrieve the latest status after a missed event.

        Get one message owned by the authenticated application.

        See [Message lifecycle events](/api/messages#lifecycle-events) for complete payload schemas and examples.
      tags:
        - smsMessages
      parameters:
        - name: message_uuid
          in: path
          required: true
          schema:
            type: string
            pattern: ^msg_[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. See [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for
            details.
          required: true
          schema:
            type: string
      responses:
        '200':
          description: The app-owned message.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SMS Messages_getMessageStatus_Response_200'
        '400':
          description: >-
            Missing `Authorization` or malformed Bearer credentials return `invalid_authorization_header`; invalid
            request parameters return `invalid_request`. A syntactically valid credential with an invalid API key
            returns `401 unauthorized` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/GetMessageStatusRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400 invalid_authorization_header`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/GetMessageStatusRequestUnauthorizedError'
        '404':
          description: The requested resource was not found or is not owned by the authenticated app.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/GetMessageStatusRequestNotFoundError'
        '500':
          description: >-
            An unexpected platform failure. Quote `support_id` to support; the technical cause and vendor event
            identifier are never exposed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
        '503':
          description: Message storage is temporarily unavailable.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/GetMessageStatusRequestServiceUnavailableError'
  /api/v1/app:
    get:
      operationId: getApplicationConfiguration
      summary: Get application configuration
      description: >-
        Get the authenticated application's assigned inbound phone numbers, permitted outbound caller IDs and SMS
        identities, webhook settings, and effective resource limits. This operation does not expose credentials or
        configuration for other applications.
      tags:
        - application
      parameters:
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. See [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for
            details.
          required: true
          schema:
            type: string
      responses:
        '200':
          description: Current application configuration
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AppConfigurationResponse'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400 invalid_authorization_header`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/GetApplicationConfigurationRequestUnauthorizedError'
        '500':
          description: >-
            An unexpected platform failure. Quote `support_id` to support; the technical cause and vendor event
            identifier are never exposed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
        '503':
          description: The application configuration is temporarily unavailable; retry the request.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/GetApplicationConfigurationRequestServiceUnavailableError'
    patch:
      operationId: updateApplicationConfiguration
      summary: Update application configuration
      description: >-
        Update the authenticated application's webhook delivery URL. Set `webhook_url` to null or an empty string to
        disable webhook delivery. Updated webhook settings apply to deliveries created after this request succeeds.
      tags:
        - application
      parameters:
        - name: Authorization
          in: header
          description: >-
            Application auth. Send `Authorization: Bearer <app_uuid>:<api_key>` using any active key in the app's
            collection. See [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for
            details.
          required: true
          schema:
            type: string
      responses:
        '204':
          description: Application configuration updated
          content:
            application/json:
              schema:
                type: object
                properties: {}
        '400':
          description: >-
            Missing `Authorization` or malformed Bearer credentials return `invalid_authorization_header`; invalid
            request parameters return `invalid_request`. A syntactically valid credential with an invalid API key
            returns `401 unauthorized` instead.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UpdateApplicationConfigurationRequestBadRequestError'
        '401':
          description: >-
            The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or
            malformed Bearer credentials return `400 invalid_authorization_header`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UpdateApplicationConfigurationRequestUnauthorizedError'
        '413':
          description: Request body exceeds the endpoint's size limit.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UpdateApplicationConfigurationRequestContentTooLargeError'
        '415':
          description: >-
            Send JSON request bodies with `Content-Type: application/json`. The API rejects an explicitly supplied
            malformed or unsupported media type.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UpdateApplicationConfigurationRequestUnsupportedMediaTypeError'
        '500':
          description: >-
            An unexpected platform failure. Quote `support_id` to support; the technical cause and vendor event
            identifier are never exposed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
        '503':
          description: The configuration store is temporarily unavailable; retry the request.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UpdateApplicationConfigurationRequestServiceUnavailableError'
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/AppConfigurationPatchRequest'
  /health:
    get:
      operationId: check
      summary: Health check
      description: Check public readiness. No authentication required.
      tags:
        - health
      responses:
        '200':
          description: Service is healthy
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Health_check_Response_200'
        '503':
          description: Service is not ready to receive traffic.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HealthCheckRequestServiceUnavailableError'
  /livez:
    get:
      operationId: livenessCheck
      summary: Liveness probe
      description: |-
        Check process **liveness**. 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: API server
components:
  schemas:
    WebhookPublicKeyAlg:
      type: string
      enum:
        - ed25519
      description: Signature algorithm. Always `ed25519`.
      title: WebhookPublicKeyAlg
    WebhookPublicKey:
      type: object
      properties:
        akid:
          type: integer
          description: Positive integer key ID used for key-set cache replacement and operator diagnostics.
        alg:
          $ref: '#/components/schemas/WebhookPublicKeyAlg'
          description: Signature algorithm. Always `ed25519`.
        public_key:
          type: string
          description: >-
            Base64-encoded Ed25519 public key. Use it to verify each base64 `v1a` signature over the exact Standard
            Webhooks signing input `<webhook-id>.<webhook-timestamp>.<raw_body>`. The decoded public key is exactly 32
            bytes.
      required:
        - akid
        - alg
        - public_key
      description: A single webhook signature public key.
      title: WebhookPublicKey
    WebhookPublicKeysResponse:
      type: object
      properties:
        keys:
          type: array
          items:
            $ref: '#/components/schemas/WebhookPublicKey'
          description: Complete active public-key set. Array order has no signing semantics.
      required:
        - keys
      description: >-
        Response of `GET /.well-known/webhook-public-keys`. Carries the cluster's Ed25519 public key(s) for verifying
        `v1a` entries in the `Webhook-Signature` header. More than one key may be present during key rotation (current +
        previous).
      title: WebhookPublicKeysResponse
    V1SessionsGetParametersState:
      type: string
      enum:
        - new
        - connecting
        - ringing
        - early_media
        - answered
        - ended
      title: V1SessionsGetParametersState
    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 WebSocket server connection has not yet been established.
      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 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. `+972500000000`). 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. `+972740000000`).
            Empty for `websocket` sessions (no phone leg).
        session_uuid:
          type: string
          description: Session identifier.
        state:
          $ref: '#/components/schemas/SessionState'
          description: |-
            Current lifecycle state of the session. `connecting` applies to a
            `websocket` session whose WebSocket server connection has not yet been established.
        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 WebSocket session with no phone leg
            - `unknown`: could not be determined
      required:
        - created_at
        - session_uuid
        - state
        - type
      description: |-
        The 6-field view of a session. Identical shape on
        `GET /v1/sessions/{uuid}` and each item of `GET /v1/sessions`.
      title: Session
    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
    ErrorResponseCode:
      type: string
      enum:
        - invalid_request
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. 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. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: ErrorResponse
    V1SessionsGetResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the HTTP
        status and operation description, not just `code`, to distinguish them.
      title: V1SessionsGetResponsesContentApplicationJsonSchemaCode
    ListSessionsRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: ListSessionsRequestUnauthorizedError
    ListSessionsRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: ListSessionsRequestContentTooLargeError
    ListSessionsRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: ListSessionsRequestTooManyRequestsError
    InternalErrorResponse:
      type: object
      properties:
        code:
          type: string
          enum:
            - internal_error
        message:
          type: string
          enum:
            - An internal error occurred
        support_id:
          type: string
          pattern: ^err_[0-9a-f]{32}$
          minLength: 36
          maxLength: 36
          description: Opaque occurrence identifier to quote to support. It is not a Sentry Event ID and must not be parsed.
      required:
        - code
        - message
        - support_id
      title: InternalErrorResponse
    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 WebSocket server connection has not yet been established.
      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 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. `+972500000000`). 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. `+972740000000`).
            Empty for `websocket` sessions (no phone leg).
        session_uuid:
          type: string
          description: Session identifier.
        status:
          $ref: '#/components/schemas/SessionDetailsStatus'
          description: |-
            Current lifecycle status of the session. `connecting` applies to a
            `websocket` session whose WebSocket server connection has not yet been established.
        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 WebSocket session with no phone leg
            - `unknown`: could not be determined
      required:
        - caller_id
        - created_at
        - did
        - session_uuid
        - status
        - type
      description: The 6-field view returned by `GET /v1/sessions/{uuid}`.
      title: SessionDetails
    V1SessionsUuidGetResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. 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. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: GetSessionDetailsRequestBadRequestError
    GetSessionDetailsRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: GetSessionDetailsRequestUnauthorizedError
    GetSessionDetailsRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: GetSessionDetailsRequestNotFoundError
    V1SessionsDialPostResponsesContentApplicationJsonSchemaStatus:
      type: string
      enum:
        - dialing
      title: V1SessionsDialPostResponsesContentApplicationJsonSchemaStatus
    Sessions & Calls_createDial_Response_202:
      type: object
      properties:
        session_uuid:
          type: string
        status:
          $ref: '#/components/schemas/V1SessionsDialPostResponsesContentApplicationJsonSchemaStatus'
      required:
        - session_uuid
        - status
      title: Sessions & Calls_createDial_Response_202
    V1SessionsDialPostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. 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. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CreateDialRequestBadRequestError
    CreateDialRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsDialPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CreateDialRequestUnauthorizedError
    CreateDialRequestForbiddenError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsDialPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CreateDialRequestForbiddenError
    CreateDialRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsDialPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CreateDialRequestConflictError
    CreateDialRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsDialPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CreateDialRequestContentTooLargeError
    CreateDialRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsDialPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CreateDialRequestUnsupportedMediaTypeError
    CreateDialRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsDialPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CreateDialRequestUnprocessableEntityError
    CreateDialRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsDialPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CreateDialRequestServiceUnavailableError
    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`, `recording.became_available`, `digits.collected`,
        `session.answered`/`session.ended`). A lifecycle event carries `operation_uuid` only when it can be
        unambiguously associated with the submitted command. The 202 response itself is the only admission
        acknowledgement.
      title: AsyncCommandResponse
    V1SessionsUuidAnswerPostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. 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. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: AnswerACallRequestBadRequestError
    AnswerACallRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidAnswerPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: AnswerACallRequestUnauthorizedError
    AnswerACallRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidAnswerPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: AnswerACallRequestNotFoundError
    AnswerACallRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidAnswerPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: AnswerACallRequestConflictError
    AnswerACallRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidAnswerPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: AnswerACallRequestContentTooLargeError
    AnswerACallRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidAnswerPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: AnswerACallRequestUnsupportedMediaTypeError
    AnswerACallRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidAnswerPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: AnswerACallRequestUnprocessableEntityError
    AnswerACallRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidAnswerPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: AnswerACallRequestServiceUnavailableError
    V1SessionsUuidRejectPostRequestBodyContentApplicationJsonSchemaReason:
      type: string
      enum:
        - number_not_found
        - invalid_number
        - timeout
        - busy
        - rejected
      description: >-
        Public hangup cause for the resulting `session.ended` event: `number_not_found`, `invalid_number`, `timeout`,
        `busy`, or `rejected`.
      title: V1SessionsUuidRejectPostRequestBodyContentApplicationJsonSchemaReason
    V1SessionsUuidRejectPostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the HTTP
        status and operation description, not just `code`, to distinguish them.
      title: V1SessionsUuidRejectPostResponsesContentApplicationJsonSchemaCode
    RejectIncomingCallRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRejectPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: RejectIncomingCallRequestBadRequestError
    RejectIncomingCallRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRejectPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: RejectIncomingCallRequestUnauthorizedError
    RejectIncomingCallRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRejectPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: RejectIncomingCallRequestNotFoundError
    RejectIncomingCallRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRejectPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: RejectIncomingCallRequestConflictError
    RejectIncomingCallRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRejectPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: RejectIncomingCallRequestContentTooLargeError
    RejectIncomingCallRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRejectPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: RejectIncomingCallRequestUnsupportedMediaTypeError
    RejectIncomingCallRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRejectPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: RejectIncomingCallRequestUnprocessableEntityError
    RejectIncomingCallRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRejectPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: RejectIncomingCallRequestServiceUnavailableError
    V1SessionsUuidCancelPostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the HTTP
        status and operation description, not just `code`, to distinguish them.
      title: V1SessionsUuidCancelPostResponsesContentApplicationJsonSchemaCode
    CancelOutgoingCallRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidCancelPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CancelOutgoingCallRequestBadRequestError
    CancelOutgoingCallRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidCancelPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CancelOutgoingCallRequestUnauthorizedError
    CancelOutgoingCallRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidCancelPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CancelOutgoingCallRequestNotFoundError
    CancelOutgoingCallRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidCancelPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CancelOutgoingCallRequestConflictError
    CancelOutgoingCallRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidCancelPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CancelOutgoingCallRequestContentTooLargeError
    CancelOutgoingCallRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidCancelPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CancelOutgoingCallRequestUnsupportedMediaTypeError
    CancelOutgoingCallRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidCancelPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CancelOutgoingCallRequestUnprocessableEntityError
    CancelOutgoingCallRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidCancelPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CancelOutgoingCallRequestServiceUnavailableError
    V1SessionsUuidDeleteResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. 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. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: DeleteSessionRequestBadRequestError
    DeleteSessionRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidDeleteResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: DeleteSessionRequestUnauthorizedError
    DeleteSessionRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidDeleteResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: DeleteSessionRequestNotFoundError
    DeleteSessionRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidDeleteResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: DeleteSessionRequestConflictError
    DeleteSessionRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidDeleteResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: DeleteSessionRequestContentTooLargeError
    DeleteSessionRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidDeleteResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: DeleteSessionRequestUnsupportedMediaTypeError
    DeleteSessionRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidDeleteResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: DeleteSessionRequestUnprocessableEntityError
    DeleteSessionRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidDeleteResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: DeleteSessionRequestServiceUnavailableError
    V1SessionsConnectWebsocketPostRequestBodyContentApplicationJsonSchemaType:
      type: string
      enum:
        - websocket
      description: Session type to create. Only `websocket` is supported.
      title: V1SessionsConnectWebsocketPostRequestBodyContentApplicationJsonSchemaType
    WebSocketMulawAudioFormatEncoding:
      type: string
      enum:
        - mulaw
      description: G.711 mu-law (`mulaw`) encoding.
      title: WebSocketMulawAudioFormatEncoding
    WebSocketMulawAudioFormatSampleRate:
      type: string
      enum:
        - '8000'
      description: Sample rate in Hz. G.711 mu-law requires `8000`.
      title: WebSocketMulawAudioFormatSampleRate
    WebSocketPcm16AudioFormatEncoding:
      type: string
      enum:
        - pcm_s16le
      description: Signed 16-bit little-endian linear PCM (`pcm_s16le`).
      title: WebSocketPcm16AudioFormatEncoding
    WebSocketAudioFormat:
      oneOf:
        - type: object
          properties:
            encoding:
              $ref: '#/components/schemas/WebSocketMulawAudioFormatEncoding'
              description: G.711 mu-law (`mulaw`) encoding.
            sample_rate:
              $ref: '#/components/schemas/WebSocketMulawAudioFormatSampleRate'
              description: Sample rate in Hz. G.711 mu-law requires `8000`.
          required:
            - encoding
            - sample_rate
          description: |-
            G.711 mu-law audio for one WebSocket Session direction. Audio is 8 kHz mono.
            Binary WebSocket frames contain raw mu-law bytes without JSON, base64, or a file header.
        - type: object
          properties:
            encoding:
              $ref: '#/components/schemas/WebSocketPcm16AudioFormatEncoding'
              description: Signed 16-bit little-endian linear PCM (`pcm_s16le`).
            sample_rate:
              type: integer
              minimum: 8000
              maximum: 192000
              multipleOf: 8000
              description: |-
                Sample rate in Hz; for example, `16000` (16 kHz). Must be a multiple of
                8000 from 8000 through 192000.
          required:
            - encoding
            - sample_rate
          description: |-
            Audio format for one direction of the WebSocket Session connection. Audio is mono.
            Binary WebSocket frames contain raw audio bytes in this format. Do not include a WAV header.
      discriminator:
        propertyName: encoding
      title: WebSocketAudioFormat
    WebSocketMediaFormat:
      type: object
      properties:
        from_session:
          $ref: '#/components/schemas/WebSocketAudioFormat'
        to_session:
          $ref: '#/components/schemas/WebSocketAudioFormat'
      required:
        - from_session
        - to_session
      description: |-
        Audio formats in both directions. `from_session` is audio sent from the
        session to the WebSocket server; `to_session` is audio sent from the
        WebSocket server to the session.
      title: WebSocketMediaFormat
    WebSocketConfig:
      type: object
      properties:
        connection_headers:
          type: object
          additionalProperties:
            type: string
          description: >-
            Customer-controlled HTTP header name→value map sent when opening the connection to the WebSocket server
            (e.g. auth).

            The platform owns User-Agent, Origin, Host, Connection, Upgrade, Sec-WebSocket-*, Content-Length,
            Transfer-Encoding, Proxy-*, Forwarded, X-Forwarded-*, X-Real-IP, and CF-Connecting-IP.

            The platform sets User-Agent and derives Origin from the target URL. Header names must be valid HTTP field
            names; bounded count and total size; values may not contain line breaks.
        media_format:
          $ref: '#/components/schemas/WebSocketMediaFormat'
        start_muted:
          type: boolean
          description: If true, audio from the session starts muted. Omit this field or set it to `false` to start unmuted.
        url:
          type: string
          format: uri
          pattern: ^wss?://
          maxLength: 4096
          description: >-
            External WebSocket URL. Use canonical `ws://host/path` or `wss://host/path` form to use the default port (80
            or 443), or include an explicit TCP port from 1 through 65535. Prefer `wss://` across untrusted networks.

            The host must resolve to a permitted public address.
      required:
        - media_format
        - url
      description: |-
        WebSocket audio connection configuration. Audio in both
        directions is raw mono PCM16 or G.711 mu-law, independently selected, and carried
        in binary WebSocket frames. Do not include a WAV header.
      title: WebSocketConfig
    V1SessionsConnectWebsocketPostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. 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. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CreateSessionRequestBadRequestError
    CreateSessionRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsConnectWebsocketPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CreateSessionRequestUnauthorizedError
    CreateSessionRequestForbiddenError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsConnectWebsocketPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CreateSessionRequestForbiddenError
    CreateSessionRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsConnectWebsocketPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CreateSessionRequestConflictError
    CreateSessionRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsConnectWebsocketPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CreateSessionRequestContentTooLargeError
    CreateSessionRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsConnectWebsocketPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CreateSessionRequestUnsupportedMediaTypeError
    CreateSessionRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsConnectWebsocketPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CreateSessionRequestUnprocessableEntityError
    CreateSessionRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsConnectWebsocketPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CreateSessionRequestServiceUnavailableError
    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.
        voice_activity_events:
          type: boolean
          description: Whether member voice activity webhooks are enabled for this room.
      required:
        - created_at
        - member_count
        - room_id
        - voice_activity_events
      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
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. 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. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: ListRoomsRequestBadRequestError
    ListRoomsRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: ListRoomsRequestUnauthorizedError
    ListRoomsRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: ListRoomsRequestContentTooLargeError
    ListRoomsRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: ListRoomsRequestTooManyRequestsError
    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
            format: uri
        playback_volume:
          type: integer
          minimum: 0
          maximum: 200
          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
        voice_activity_events:
          type: boolean
          description: Whether member voice activity webhooks are enabled for this room.
      required:
        - created_at
        - member_count
        - playback_operation_uuid
        - playback_status
        - playback_urls
        - playback_volume
        - room_id
        - voice_activity_events
      title: Room
    ApiV1RoomsRoomIdGetResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. 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. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: GetRoomStatusRequestBadRequestError
    GetRoomStatusRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: GetRoomStatusRequestUnauthorizedError
    GetRoomStatusRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: GetRoomStatusRequestNotFoundError
    Rooms_createRoom_Response_201:
      type: object
      properties:
        room_id:
          type: string
          description: Room identifier.
        voice_activity_events:
          type: boolean
          description: Whether member voice activity webhooks are enabled for this room.
      required:
        - room_id
        - voice_activity_events
      title: Rooms_createRoom_Response_201
    ApiV1RoomsPostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. 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. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CreateRoomRequestBadRequestError
    CreateRoomRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CreateRoomRequestUnauthorizedError
    CreateRoomRequestForbiddenError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CreateRoomRequestForbiddenError
    CreateRoomRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CreateRoomRequestConflictError
    CreateRoomRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CreateRoomRequestContentTooLargeError
    CreateRoomRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CreateRoomRequestUnsupportedMediaTypeError
    CreateRoomRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CreateRoomRequestUnprocessableEntityError
    CreateRoomRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CreateRoomRequestTooManyRequestsError
    CreateRoomRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      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
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. 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. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: DeleteRoomRequestBadRequestError
    DeleteRoomRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdDeleteResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: DeleteRoomRequestUnauthorizedError
    DeleteRoomRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdDeleteResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: DeleteRoomRequestNotFoundError
    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
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. 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. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: ListRoomMembersRequestBadRequestError
    ListRoomMembersRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdMembersGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: ListRoomMembersRequestUnauthorizedError
    ListRoomMembersRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdMembersGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: ListRoomMembersRequestNotFoundError
    ListRoomMembersRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdMembersGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: ListRoomMembersRequestContentTooLargeError
    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
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. 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. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: AddRoomMemberRequestBadRequestError
    AddRoomMemberRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdMembersPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: AddRoomMemberRequestUnauthorizedError
    AddRoomMemberRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdMembersPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: AddRoomMemberRequestNotFoundError
    AddRoomMemberRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdMembersPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: AddRoomMemberRequestContentTooLargeError
    AddRoomMemberRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdMembersPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: AddRoomMemberRequestUnsupportedMediaTypeError
    AddRoomMemberRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdMembersPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: AddRoomMemberRequestUnprocessableEntityError
    AddRoomMemberRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdMembersPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: AddRoomMemberRequestTooManyRequestsError
    AddRoomMemberRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdMembersPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: AddRoomMemberRequestServiceUnavailableError
    ApiV1RoomsRoomIdMembersUuidGetResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. 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. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: GetRoomMemberRequestBadRequestError
    GetRoomMemberRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdMembersUuidGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: GetRoomMemberRequestUnauthorizedError
    GetRoomMemberRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdMembersUuidGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: GetRoomMemberRequestNotFoundError
    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
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. 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. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: RemoveRoomMemberRequestBadRequestError
    RemoveRoomMemberRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdMembersUuidDeleteResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: RemoveRoomMemberRequestUnauthorizedError
    RemoveRoomMemberRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdMembersUuidDeleteResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: RemoveRoomMemberRequestNotFoundError
    RemoveRoomMemberRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdMembersUuidDeleteResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: RemoveRoomMemberRequestConflictError
    RemoveRoomMemberRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdMembersUuidDeleteResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: RemoveRoomMemberRequestTooManyRequestsError
    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
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. 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. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: MuteRoomMemberRequestBadRequestError
    MuteRoomMemberRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRoomMutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: MuteRoomMemberRequestUnauthorizedError
    MuteRoomMemberRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRoomMutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: MuteRoomMemberRequestNotFoundError
    MuteRoomMemberRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRoomMutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: MuteRoomMemberRequestConflictError
    MuteRoomMemberRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRoomMutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: MuteRoomMemberRequestContentTooLargeError
    MuteRoomMemberRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRoomMutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: MuteRoomMemberRequestUnsupportedMediaTypeError
    MuteRoomMemberRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRoomMutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: MuteRoomMemberRequestUnprocessableEntityError
    MuteRoomMemberRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRoomMutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      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
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. 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. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: UnmuteRoomMemberRequestBadRequestError
    UnmuteRoomMemberRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRoomUnmutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: UnmuteRoomMemberRequestUnauthorizedError
    UnmuteRoomMemberRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRoomUnmutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: UnmuteRoomMemberRequestNotFoundError
    UnmuteRoomMemberRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRoomUnmutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: UnmuteRoomMemberRequestConflictError
    UnmuteRoomMemberRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRoomUnmutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: UnmuteRoomMemberRequestContentTooLargeError
    UnmuteRoomMemberRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRoomUnmutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: UnmuteRoomMemberRequestUnsupportedMediaTypeError
    UnmuteRoomMemberRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRoomUnmutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: UnmuteRoomMemberRequestUnprocessableEntityError
    UnmuteRoomMemberRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRoomUnmutePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: UnmuteRoomMemberRequestServiceUnavailableError
    V1SessionsUuidRoomVolumePostRequestBodyContentApplicationJsonSchemaDirection:
      type: string
      enum:
        - to_member
        - from_member
        - both
      description: Room-member-relative direction. to_member = member hears Room; from_member = Room hears member; both = both.
      title: V1SessionsUuidRoomVolumePostRequestBodyContentApplicationJsonSchemaDirection
    V1SessionsUuidRoomVolumePostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. 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. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: SetRoomMemberVolumeRequestBadRequestError
    SetRoomMemberVolumeRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRoomVolumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: SetRoomMemberVolumeRequestUnauthorizedError
    SetRoomMemberVolumeRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRoomVolumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: SetRoomMemberVolumeRequestNotFoundError
    SetRoomMemberVolumeRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRoomVolumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: SetRoomMemberVolumeRequestConflictError
    SetRoomMemberVolumeRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRoomVolumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: SetRoomMemberVolumeRequestContentTooLargeError
    SetRoomMemberVolumeRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRoomVolumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: SetRoomMemberVolumeRequestUnsupportedMediaTypeError
    SetRoomMemberVolumeRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRoomVolumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: SetRoomMemberVolumeRequestUnprocessableEntityError
    SetRoomMemberVolumeRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRoomVolumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: SetRoomMemberVolumeRequestServiceUnavailableError
    RoomPlaybackPlayAudioInRoomRequest0:
      type: object
      properties:
        loop:
          type: boolean
          description: >-
            Replay the finite source from the beginning whenever it finishes. Omit this field or set it to `false` to
            play the source once.
        offset_ms:
          type: integer
          minimum: 0
          maximum: 86400000
          description: |-
            Optional starting offset in milliseconds. It is valid only
            with one finite source.
        type:
          type: string
          enum:
            - files
          description: Selects finite-file playback.
        urls:
          type: array
          items:
            type: string
            format: uri
            pattern: ^https?://
            maxLength: 2048
          description: |-
            HTTP/HTTPS URLs of WAV or MP3 audio files to play sequentially. With two
            or more assets, playback is one continuous playlist, but seeking
            across playlist asset boundaries is undefined.
      required:
        - type
        - urls
      title: RoomPlaybackPlayAudioInRoomRequest0
    RoomPlaybackPlayAudioInRoomRequest1:
      type: object
      properties:
        type:
          type: string
          enum:
            - stream
          description: Selects live-stream playback.
        url:
          type: string
          format: uri
          pattern: ^https?://
          maxLength: 2048
          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
    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
    ApiV1RoomsRoomIdPlaybackPlayPostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. 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. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: PlayAudioInRoomRequestBadRequestError
    PlayAudioInRoomRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackPlayPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: PlayAudioInRoomRequestUnauthorizedError
    PlayAudioInRoomRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackPlayPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: PlayAudioInRoomRequestNotFoundError
    PlayAudioInRoomRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackPlayPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: PlayAudioInRoomRequestConflictError
    PlayAudioInRoomRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackPlayPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: PlayAudioInRoomRequestContentTooLargeError
    PlayAudioInRoomRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackPlayPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: PlayAudioInRoomRequestUnsupportedMediaTypeError
    PlayAudioInRoomRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackPlayPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: PlayAudioInRoomRequestUnprocessableEntityError
    PlayAudioInRoomRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackPlayPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: PlayAudioInRoomRequestTooManyRequestsError
    PlaybackSourceErrorResponseDetailReason:
      type: string
      enum:
        - unsupported
        - not_found
        - access_denied
        - timeout
        - unreachable
        - rejected
        - invalid_response
        - preparation_failed
      description: Actionable failure category for the source or its preparation.
      title: PlaybackSourceErrorResponseDetailReason
    PlaybackSourceErrorResponseDetail:
      type: object
      properties:
        reason:
          $ref: '#/components/schemas/PlaybackSourceErrorResponseDetailReason'
          description: Actionable failure category for the source or its preparation.
        retryable:
          type: boolean
          description: Whether retrying the same request later may succeed without changing the source.
        source_index:
          type: integer
          minimum: 0
          maximum: 127
          description: Zero-based index in the submitted source array.
        upstream_status:
          type: integer
          minimum: 100
          maximum: 599
          description: HTTP status returned by the source origin, when one was received.
      required:
        - reason
        - retryable
      description: >-
        Bounded diagnostics for the playback source failure. These fields never contain source URLs, credentials,
        filesystem paths, raw upstream bodies, or media-engine details.
      title: PlaybackSourceErrorResponseDetail
    PlaybackSourceErrorResponse:
      type: object
      properties:
        code:
          type: string
          enum:
            - playback_source_error
          description: Stable machine-readable error code for a playback source failure.
        detail:
          $ref: '#/components/schemas/PlaybackSourceErrorResponseDetail'
          description: >-
            Bounded diagnostics for the playback source failure. These fields never contain source URLs, credentials,
            filesystem paths, raw upstream bodies, or media-engine details.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - detail
        - message
      title: PlaybackSourceErrorResponse
    PlayAudioInRoomRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackPlayPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: PlayAudioInRoomRequestServiceUnavailableError
    ApiV1RoomsRoomIdPlaybackPausePostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. 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. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: PauseRoomPlaybackRequestBadRequestError
    PauseRoomPlaybackRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackPausePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: PauseRoomPlaybackRequestUnauthorizedError
    PauseRoomPlaybackRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackPausePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: PauseRoomPlaybackRequestNotFoundError
    PauseRoomPlaybackRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackPausePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: PauseRoomPlaybackRequestConflictError
    PauseRoomPlaybackRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackPausePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: PauseRoomPlaybackRequestContentTooLargeError
    PauseRoomPlaybackRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackPausePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: PauseRoomPlaybackRequestUnsupportedMediaTypeError
    PauseRoomPlaybackRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackPausePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: PauseRoomPlaybackRequestUnprocessableEntityError
    PauseRoomPlaybackRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackPausePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: PauseRoomPlaybackRequestTooManyRequestsError
    PauseRoomPlaybackRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackPausePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: PauseRoomPlaybackRequestServiceUnavailableError
    ApiV1RoomsRoomIdPlaybackRecordPostResponsesContentApplicationJsonSchemaStatus:
      type: string
      enum:
        - in_progress
      title: ApiV1RoomsRoomIdPlaybackRecordPostResponsesContentApplicationJsonSchemaStatus
    RecordingURLReference:
      type: string
      format: uri
      pattern: ^https://
      description: |-
        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
          pattern: ^rec_[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
          description: Stable 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 media_url, derived from the URL's signed expiration.
        media_url:
          $ref: '#/components/schemas/RecordingURLReference'
          description: |-
            Starts at byte zero and follows the growing Recording until EOF. After
            finalization, the same URL serves a finite, range-capable WAV. Validity defaults to 24 hours.
      required:
        - operation_uuid
        - status
        - recording_uuid
        - expires_at
        - media_url
      description: Accepted response with the command acknowledgement and current Recording details.
      title: Room Playback_startRoomRecording_Response_202
    ApiV1RoomsRoomIdPlaybackRecordPostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. 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. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StartRoomRecordingRequestBadRequestError
    StartRoomRecordingRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackRecordPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StartRoomRecordingRequestUnauthorizedError
    StartRoomRecordingRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackRecordPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StartRoomRecordingRequestNotFoundError
    StartRoomRecordingRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackRecordPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StartRoomRecordingRequestConflictError
    StartRoomRecordingRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackRecordPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StartRoomRecordingRequestUnprocessableEntityError
    StartRoomRecordingRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackRecordPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StartRoomRecordingRequestTooManyRequestsError
    StartRoomRecordingRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackRecordPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      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
          pattern: ^rec_[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
          description: Stable 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 media_url, derived from the URL's signed expiration.
        media_url:
          $ref: '#/components/schemas/RecordingURLReference'
          description: >-
            Starts at byte zero and follows the growing Recording until EOF. After

            finalization, the same URL serves a finite, range-capable WAV. A boundary request may briefly wait for
            internal finalization. Validity defaults to 24 hours.
      required:
        - operation_uuid
        - status
        - recording_uuid
        - expires_at
        - media_url
      description: Flat accepted response for a room Recording stop.
      title: Room Playback_stopRoomRecording_Response_202
    ApiV1RoomsRoomIdPlaybackRecordStopPostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. 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. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StopRoomRecordingRequestBadRequestError
    StopRoomRecordingRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackRecordStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StopRoomRecordingRequestUnauthorizedError
    StopRoomRecordingRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackRecordStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StopRoomRecordingRequestNotFoundError
    StopRoomRecordingRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackRecordStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StopRoomRecordingRequestConflictError
    StopRoomRecordingRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackRecordStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StopRoomRecordingRequestTooManyRequestsError
    StopRoomRecordingRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackRecordStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StopRoomRecordingRequestServiceUnavailableError
    ApiV1RoomsRoomIdPlaybackSeekPostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. 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. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: SeekRoomPlaybackRequestBadRequestError
    SeekRoomPlaybackRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackSeekPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: SeekRoomPlaybackRequestUnauthorizedError
    SeekRoomPlaybackRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackSeekPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: SeekRoomPlaybackRequestNotFoundError
    SeekRoomPlaybackRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackSeekPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: SeekRoomPlaybackRequestConflictError
    SeekRoomPlaybackRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackSeekPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: SeekRoomPlaybackRequestContentTooLargeError
    SeekRoomPlaybackRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackSeekPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: SeekRoomPlaybackRequestUnsupportedMediaTypeError
    SeekRoomPlaybackRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackSeekPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: SeekRoomPlaybackRequestUnprocessableEntityError
    SeekRoomPlaybackRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackSeekPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: SeekRoomPlaybackRequestTooManyRequestsError
    SeekRoomPlaybackRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackSeekPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: SeekRoomPlaybackRequestServiceUnavailableError
    ApiV1RoomsRoomIdPlaybackStopPostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. 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. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StopRoomPlaybackRequestBadRequestError
    StopRoomPlaybackRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StopRoomPlaybackRequestUnauthorizedError
    StopRoomPlaybackRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StopRoomPlaybackRequestNotFoundError
    StopRoomPlaybackRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StopRoomPlaybackRequestConflictError
    StopRoomPlaybackRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StopRoomPlaybackRequestContentTooLargeError
    StopRoomPlaybackRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StopRoomPlaybackRequestUnsupportedMediaTypeError
    StopRoomPlaybackRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StopRoomPlaybackRequestUnprocessableEntityError
    StopRoomPlaybackRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StopRoomPlaybackRequestTooManyRequestsError
    StopRoomPlaybackRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StopRoomPlaybackRequestServiceUnavailableError
    ApiV1RoomsRoomIdPlaybackVolumePostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. 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. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: SetRoomVolumeRequestBadRequestError
    SetRoomVolumeRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackVolumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: SetRoomVolumeRequestUnauthorizedError
    SetRoomVolumeRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackVolumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: SetRoomVolumeRequestNotFoundError
    SetRoomVolumeRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackVolumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: SetRoomVolumeRequestConflictError
    SetRoomVolumeRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackVolumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: SetRoomVolumeRequestContentTooLargeError
    SetRoomVolumeRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackVolumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: SetRoomVolumeRequestUnsupportedMediaTypeError
    SetRoomVolumeRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackVolumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: SetRoomVolumeRequestUnprocessableEntityError
    SetRoomVolumeRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackVolumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: SetRoomVolumeRequestTooManyRequestsError
    SetRoomVolumeRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackVolumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: SetRoomVolumeRequestServiceUnavailableError
    ApiV1RoomsRoomIdPlaybackResumePostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the HTTP
        status and operation description, not just `code`, to distinguish them.
      title: ApiV1RoomsRoomIdPlaybackResumePostResponsesContentApplicationJsonSchemaCode
    ResumeRoomPlaybackRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackResumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: ResumeRoomPlaybackRequestBadRequestError
    ResumeRoomPlaybackRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackResumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: ResumeRoomPlaybackRequestUnauthorizedError
    ResumeRoomPlaybackRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackResumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: ResumeRoomPlaybackRequestNotFoundError
    ResumeRoomPlaybackRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackResumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: ResumeRoomPlaybackRequestConflictError
    ResumeRoomPlaybackRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackResumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: ResumeRoomPlaybackRequestUnprocessableEntityError
    ResumeRoomPlaybackRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackResumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: ResumeRoomPlaybackRequestTooManyRequestsError
    ResumeRoomPlaybackRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1RoomsRoomIdPlaybackResumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: ResumeRoomPlaybackRequestServiceUnavailableError
    SessionRecordingResource:
      type: object
      properties:
        channels:
          type: string
        created_at:
          type: string
        direction:
          type: string
        include_gaps:
          type: boolean
        recording_uuid:
          type: string
        status:
          type: string
      required:
        - channels
        - created_at
        - direction
        - include_gaps
        - recording_uuid
        - status
      title: SessionRecordingResource
    SessionRecordingListBody:
      type: object
      properties:
        recordings:
          type:
            - array
            - 'null'
          items:
            $ref: '#/components/schemas/SessionRecordingResource'
      required:
        - recordings
      title: SessionRecordingListBody
    V1SessionsUuidRecordingsGetResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the HTTP
        status and operation description, not just `code`, to distinguish them.
      title: V1SessionsUuidRecordingsGetResponsesContentApplicationJsonSchemaCode
    ListSessionRecordingsRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingsGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: ListSessionRecordingsRequestBadRequestError
    ListSessionRecordingsRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingsGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: ListSessionRecordingsRequestUnauthorizedError
    ListSessionRecordingsRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingsGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: ListSessionRecordingsRequestNotFoundError
    ListSessionRecordingsRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingsGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: ListSessionRecordingsRequestServiceUnavailableError
    V1SessionsUuidRecordingsRecordingUuidGetResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the HTTP
        status and operation description, not just `code`, to distinguish them.
      title: V1SessionsUuidRecordingsRecordingUuidGetResponsesContentApplicationJsonSchemaCode
    GetSessionRecordingRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingsRecordingUuidGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: GetSessionRecordingRequestBadRequestError
    GetSessionRecordingRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingsRecordingUuidGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: GetSessionRecordingRequestUnauthorizedError
    GetSessionRecordingRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingsRecordingUuidGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: GetSessionRecordingRequestNotFoundError
    GetSessionRecordingRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingsRecordingUuidGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: GetSessionRecordingRequestServiceUnavailableError
    V1SessionsUuidRecordingsPostRequestBodyContentApplicationJsonSchemaChannels:
      type: string
      enum:
        - mono
        - stereo
      description: Output channel layout. Phase 1 supports `mono`.
      title: V1SessionsUuidRecordingsPostRequestBodyContentApplicationJsonSchemaChannels
    V1SessionsUuidRecordingsPostRequestBodyContentApplicationJsonSchemaDirection:
      type: string
      enum:
        - both
        - session_in
        - session_out
      description: Audio direction relative to the Session. Phase 1 supports `both`.
      title: V1SessionsUuidRecordingsPostRequestBodyContentApplicationJsonSchemaDirection
    V1SessionsUuidRecordingsPostRequestBodyContentApplicationJsonSchemaVoiceActivityConfig:
      type: object
      properties:
        sensitivity:
          type: integer
          minimum: 0
          maximum: 100
          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
          minimum: 20
          maximum: 3600000
          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
          minimum: 20
          maximum: 5000
          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: V1SessionsUuidRecordingsPostRequestBodyContentApplicationJsonSchemaVoiceActivityConfig
    V1SessionsUuidRecordingsPostResponsesContentApplicationJsonSchemaStatus:
      type: string
      enum:
        - in_progress
      title: V1SessionsUuidRecordingsPostResponsesContentApplicationJsonSchemaStatus
    Recording_startRecording_Response_202:
      type: object
      properties:
        operation_uuid:
          type: string
          format: uuid
        recording_uuid:
          type: string
          pattern: ^rec_[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
        status:
          $ref: '#/components/schemas/V1SessionsUuidRecordingsPostResponsesContentApplicationJsonSchemaStatus'
      required:
        - operation_uuid
        - recording_uuid
        - status
      title: Recording_startRecording_Response_202
    V1SessionsUuidRecordingsPostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the HTTP
        status and operation description, not just `code`, to distinguish them.
      title: V1SessionsUuidRecordingsPostResponsesContentApplicationJsonSchemaCode
    StartRecordingRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingsPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StartRecordingRequestBadRequestError
    StartRecordingRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingsPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StartRecordingRequestUnauthorizedError
    StartRecordingRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingsPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StartRecordingRequestNotFoundError
    StartRecordingRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingsPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StartRecordingRequestConflictError
    StartRecordingRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingsPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StartRecordingRequestContentTooLargeError
    StartRecordingRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingsPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StartRecordingRequestUnsupportedMediaTypeError
    StartRecordingRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingsPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StartRecordingRequestUnprocessableEntityError
    StartRecordingRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingsPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StartRecordingRequestTooManyRequestsError
    StartRecordingRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingsPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StartRecordingRequestServiceUnavailableError
    V1SessionsUuidRecordingsRecordingUuidStopPostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the HTTP
        status and operation description, not just `code`, to distinguish them.
      title: V1SessionsUuidRecordingsRecordingUuidStopPostResponsesContentApplicationJsonSchemaCode
    StopRecordingRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingsRecordingUuidStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StopRecordingRequestBadRequestError
    StopRecordingRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingsRecordingUuidStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StopRecordingRequestUnauthorizedError
    StopRecordingRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingsRecordingUuidStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StopRecordingRequestNotFoundError
    StopRecordingRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingsRecordingUuidStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StopRecordingRequestConflictError
    StopRecordingRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingsRecordingUuidStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StopRecordingRequestContentTooLargeError
    StopRecordingRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingsRecordingUuidStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StopRecordingRequestUnsupportedMediaTypeError
    StopRecordingRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingsRecordingUuidStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StopRecordingRequestUnprocessableEntityError
    StopRecordingRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingsRecordingUuidStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StopRecordingRequestTooManyRequestsError
    StopRecordingRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingsRecordingUuidStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StopRecordingRequestServiceUnavailableError
    V1SessionsUuidRecordingsRecordingUuidMaskPostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the HTTP
        status and operation description, not just `code`, to distinguish them.
      title: V1SessionsUuidRecordingsRecordingUuidMaskPostResponsesContentApplicationJsonSchemaCode
    MaskRecordingRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingsRecordingUuidMaskPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: MaskRecordingRequestBadRequestError
    MaskRecordingRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingsRecordingUuidMaskPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: MaskRecordingRequestUnauthorizedError
    MaskRecordingRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingsRecordingUuidMaskPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: MaskRecordingRequestNotFoundError
    MaskRecordingRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingsRecordingUuidMaskPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: MaskRecordingRequestConflictError
    MaskRecordingRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingsRecordingUuidMaskPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: MaskRecordingRequestContentTooLargeError
    MaskRecordingRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingsRecordingUuidMaskPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: MaskRecordingRequestUnsupportedMediaTypeError
    MaskRecordingRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingsRecordingUuidMaskPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: MaskRecordingRequestUnprocessableEntityError
    MaskRecordingRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingsRecordingUuidMaskPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: MaskRecordingRequestTooManyRequestsError
    MaskRecordingRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidRecordingsRecordingUuidMaskPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: MaskRecordingRequestServiceUnavailableError
    V1SessionsUuidRecordingsRecordingUuidUnmaskPostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the HTTP
        status and operation description, not just `code`, to distinguish them.
      title: V1SessionsUuidRecordingsRecordingUuidUnmaskPostResponsesContentApplicationJsonSchemaCode
    UnmaskRecordingRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: >-
            #/components/schemas/V1SessionsUuidRecordingsRecordingUuidUnmaskPostResponsesContentApplicationJsonSchemaCode
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: UnmaskRecordingRequestBadRequestError
    UnmaskRecordingRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: >-
            #/components/schemas/V1SessionsUuidRecordingsRecordingUuidUnmaskPostResponsesContentApplicationJsonSchemaCode
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: UnmaskRecordingRequestUnauthorizedError
    UnmaskRecordingRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: >-
            #/components/schemas/V1SessionsUuidRecordingsRecordingUuidUnmaskPostResponsesContentApplicationJsonSchemaCode
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: UnmaskRecordingRequestNotFoundError
    UnmaskRecordingRequestConflictError:
      type: object
      properties:
        code:
          $ref: >-
            #/components/schemas/V1SessionsUuidRecordingsRecordingUuidUnmaskPostResponsesContentApplicationJsonSchemaCode
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: UnmaskRecordingRequestConflictError
    UnmaskRecordingRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: >-
            #/components/schemas/V1SessionsUuidRecordingsRecordingUuidUnmaskPostResponsesContentApplicationJsonSchemaCode
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: UnmaskRecordingRequestContentTooLargeError
    UnmaskRecordingRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: >-
            #/components/schemas/V1SessionsUuidRecordingsRecordingUuidUnmaskPostResponsesContentApplicationJsonSchemaCode
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: UnmaskRecordingRequestUnsupportedMediaTypeError
    UnmaskRecordingRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: >-
            #/components/schemas/V1SessionsUuidRecordingsRecordingUuidUnmaskPostResponsesContentApplicationJsonSchemaCode
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: UnmaskRecordingRequestUnprocessableEntityError
    UnmaskRecordingRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: >-
            #/components/schemas/V1SessionsUuidRecordingsRecordingUuidUnmaskPostResponsesContentApplicationJsonSchemaCode
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: UnmaskRecordingRequestTooManyRequestsError
    UnmaskRecordingRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: >-
            #/components/schemas/V1SessionsUuidRecordingsRecordingUuidUnmaskPostResponsesContentApplicationJsonSchemaCode
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: UnmaskRecordingRequestServiceUnavailableError
    SessionPlaybackFilesRequest:
      type: object
      properties:
        offset_ms:
          type: integer
          minimum: 0
          maximum: 86400000
          description: |-
            Optional starting offset in milliseconds. It is valid only
            with one finite source.
        type:
          type: string
          enum:
            - files
          description: Selects finite-file playback.
        urls:
          type: array
          items:
            type: string
            format: uri
            pattern: ^https?://
            maxLength: 2048
          description: |-
            HTTP/HTTPS URLs of WAV or MP3 audio files to play sequentially. With two
            or more assets, playback is one continuous playlist, but seeking
            across playlist asset boundaries is undefined.
      required:
        - type
        - urls
      description: Play one or more WAV or MP3 files in order.
      title: SessionPlaybackFilesRequest
    SessionPlaybackPushRequestMediaFormatOneOf0SampleRate:
      type: string
      enum:
        - '8000'
        - '16000'
        - '24000'
        - '48000'
      title: SessionPlaybackPushRequestMediaFormatOneOf0SampleRate
    SessionPlaybackPushRequestMediaFormat0:
      type: object
      properties:
        encoding:
          type: string
          enum:
            - pcm_s16le
        sample_rate:
          $ref: '#/components/schemas/SessionPlaybackPushRequestMediaFormatOneOf0SampleRate'
      required:
        - encoding
        - sample_rate
      title: SessionPlaybackPushRequestMediaFormat0
    SessionPlaybackPushRequestMediaFormatOneOf1SampleRate:
      type: string
      enum:
        - '8000'
      title: SessionPlaybackPushRequestMediaFormatOneOf1SampleRate
    SessionPlaybackPushRequestMediaFormat1:
      type: object
      properties:
        encoding:
          type: string
          enum:
            - mulaw
        sample_rate:
          $ref: '#/components/schemas/SessionPlaybackPushRequestMediaFormatOneOf1SampleRate'
      required:
        - encoding
        - sample_rate
      title: SessionPlaybackPushRequestMediaFormat1
    SessionPlaybackPushRequestMediaFormat:
      oneOf:
        - $ref: '#/components/schemas/SessionPlaybackPushRequestMediaFormat0'
        - $ref: '#/components/schemas/SessionPlaybackPushRequestMediaFormat1'
      description: Raw mono audio carried in the upload request body. PCM16 is little-endian; mu-law is 8 kHz.
      title: SessionPlaybackPushRequestMediaFormat
    SessionPlaybackPushRequest:
      type: object
      properties:
        media_format:
          $ref: '#/components/schemas/SessionPlaybackPushRequestMediaFormat'
          description: Raw mono audio carried in the upload request body. PCM16 is little-endian; mu-law is 8 kHz.
        type:
          type: string
          enum:
            - push
          description: Selects generated audio pushed through the returned upload target.
      required:
        - media_format
        - type
      description: Play raw mono audio uploaded live through the returned HTTPS target.
      title: SessionPlaybackPushRequest
    SessionPlaybackStreamRequest:
      type: object
      properties:
        type:
          type: string
          enum:
            - stream
          description: Selects hosted live-stream playback.
        url:
          type: string
          format: uri
          pattern: ^https?://
          maxLength: 2048
          description: The hosted HTTP/HTTPS AAC stream to play from its current position.
      required:
        - type
        - url
      description: Play one hosted HTTP/HTTPS AAC stream from its current live position.
      title: SessionPlaybackStreamRequest
    SessionPlaybackSilenceRequest:
      type: object
      properties:
        type:
          type: string
          enum:
            - silence
          description: Selects indefinite silence playback until replaced or stopped.
      required:
        - type
      description: Play indefinite silence until playback is replaced or stopped.
      title: SessionPlaybackSilenceRequest
    SessionPlaybackRequest:
      oneOf:
        - $ref: '#/components/schemas/SessionPlaybackFilesRequest'
        - $ref: '#/components/schemas/SessionPlaybackPushRequest'
        - $ref: '#/components/schemas/SessionPlaybackStreamRequest'
        - $ref: '#/components/schemas/SessionPlaybackSilenceRequest'
      description: Playback request. Choose exactly one file, pushed-audio, hosted-stream, or silence shape.
      title: SessionPlaybackRequest
    V1SessionsUuidPlaybackPlayPostResponsesContentApplicationJsonSchemaIngestHeaders:
      type: object
      properties:
        Content-Type:
          type: string
          enum:
            - application/octet-stream
      required:
        - Content-Type
      description: >-
        Ingest-specific HTTP headers required on the request. Send every returned header unchanged, and also add the
        normal application Bearer authorization header.
      title: V1SessionsUuidPlaybackPlayPostResponsesContentApplicationJsonSchemaIngestHeaders
    V1SessionsUuidPlaybackPlayPostResponsesContentApplicationJsonSchemaIngest:
      type: object
      properties:
        expires_at:
          type: string
          format: date-time
          description: >-
            Last instant at which the one-shot ingest request may be opened. A request accepted before this instant may
            continue streaming afterward.
        headers:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackPlayPostResponsesContentApplicationJsonSchemaIngestHeaders'
          description: >-
            Ingest-specific HTTP headers required on the request. Send every returned header unchanged, and also add the
            normal application Bearer authorization header.
        method:
          type: string
          enum:
            - POST
          description: HTTP method required by the ingest endpoint.
        url:
          type: string
          format: uri
          pattern: ^https://
          description: Short-lived, single-use HTTPS ingest URL.
      required:
        - expires_at
        - headers
        - method
        - url
      description: >-
        Present only for `type: push`. Send one streaming HTTP request exactly as described by this object, plus the
        normal application Bearer authorization header.
      title: V1SessionsUuidPlaybackPlayPostResponsesContentApplicationJsonSchemaIngest
    V1SessionsUuidPlaybackPlayPostResponsesContentApplicationJsonSchemaStatus:
      type: string
      enum:
        - in_progress
      title: V1SessionsUuidPlaybackPlayPostResponsesContentApplicationJsonSchemaStatus
    Playback_startAudioPlayback_Response_202:
      type: object
      properties:
        ingest:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackPlayPostResponsesContentApplicationJsonSchemaIngest'
          description: >-
            Present only for `type: push`. Send one streaming HTTP request exactly as described by this object, plus the
            normal application Bearer authorization header.
        operation_uuid:
          type: string
          format: uuid
          pattern: ^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
        status:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackPlayPostResponsesContentApplicationJsonSchemaStatus'
      required:
        - operation_uuid
        - status
      title: Playback_startAudioPlayback_Response_202
    V1SessionsUuidPlaybackPlayPostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. 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. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StartAudioPlaybackRequestBadRequestError
    StartAudioPlaybackRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackPlayPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StartAudioPlaybackRequestUnauthorizedError
    StartAudioPlaybackRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackPlayPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StartAudioPlaybackRequestNotFoundError
    StartAudioPlaybackRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackPlayPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StartAudioPlaybackRequestConflictError
    StartAudioPlaybackRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackPlayPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StartAudioPlaybackRequestContentTooLargeError
    StartAudioPlaybackRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackPlayPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StartAudioPlaybackRequestUnsupportedMediaTypeError
    StartAudioPlaybackRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackPlayPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StartAudioPlaybackRequestUnprocessableEntityError
    StartAudioPlaybackRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackPlayPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StartAudioPlaybackRequestTooManyRequestsError
    StartAudioPlaybackRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackPlayPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StartAudioPlaybackRequestServiceUnavailableError
    V1SessionsUuidPlaybackPausePostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. 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. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: PausePlaybackRequestBadRequestError
    PausePlaybackRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackPausePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: PausePlaybackRequestUnauthorizedError
    PausePlaybackRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackPausePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: PausePlaybackRequestNotFoundError
    PausePlaybackRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackPausePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: PausePlaybackRequestConflictError
    PausePlaybackRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackPausePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: PausePlaybackRequestContentTooLargeError
    PausePlaybackRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackPausePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: PausePlaybackRequestUnsupportedMediaTypeError
    PausePlaybackRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackPausePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: PausePlaybackRequestUnprocessableEntityError
    PausePlaybackRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackPausePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: PausePlaybackRequestTooManyRequestsError
    PausePlaybackRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackPausePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: PausePlaybackRequestServiceUnavailableError
    V1SessionsUuidPlaybackResumePostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. 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. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: ResumePlaybackRequestBadRequestError
    ResumePlaybackRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackResumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: ResumePlaybackRequestUnauthorizedError
    ResumePlaybackRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackResumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: ResumePlaybackRequestNotFoundError
    ResumePlaybackRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackResumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: ResumePlaybackRequestConflictError
    ResumePlaybackRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackResumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: ResumePlaybackRequestContentTooLargeError
    ResumePlaybackRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackResumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: ResumePlaybackRequestUnsupportedMediaTypeError
    ResumePlaybackRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackResumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: ResumePlaybackRequestUnprocessableEntityError
    ResumePlaybackRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackResumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: ResumePlaybackRequestTooManyRequestsError
    ResumePlaybackRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackResumePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: ResumePlaybackRequestServiceUnavailableError
    V1SessionsUuidPlaybackSeekPostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. 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. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: SeekWithinPlaybackRequestBadRequestError
    SeekWithinPlaybackRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackSeekPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: SeekWithinPlaybackRequestUnauthorizedError
    SeekWithinPlaybackRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackSeekPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: SeekWithinPlaybackRequestNotFoundError
    SeekWithinPlaybackRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackSeekPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: SeekWithinPlaybackRequestConflictError
    SeekWithinPlaybackRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackSeekPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: SeekWithinPlaybackRequestContentTooLargeError
    SeekWithinPlaybackRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackSeekPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: SeekWithinPlaybackRequestUnsupportedMediaTypeError
    SeekWithinPlaybackRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackSeekPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: SeekWithinPlaybackRequestUnprocessableEntityError
    SeekWithinPlaybackRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackSeekPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: SeekWithinPlaybackRequestTooManyRequestsError
    SeekWithinPlaybackRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackSeekPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: SeekWithinPlaybackRequestServiceUnavailableError
    V1SessionsUuidPlaybackRestartPostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. 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. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: RestartPlaybackRequestBadRequestError
    RestartPlaybackRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackRestartPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: RestartPlaybackRequestUnauthorizedError
    RestartPlaybackRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackRestartPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: RestartPlaybackRequestNotFoundError
    RestartPlaybackRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackRestartPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: RestartPlaybackRequestConflictError
    RestartPlaybackRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackRestartPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: RestartPlaybackRequestContentTooLargeError
    RestartPlaybackRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackRestartPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: RestartPlaybackRequestUnsupportedMediaTypeError
    RestartPlaybackRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackRestartPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: RestartPlaybackRequestUnprocessableEntityError
    RestartPlaybackRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackRestartPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: RestartPlaybackRequestTooManyRequestsError
    RestartPlaybackRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackRestartPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: RestartPlaybackRequestServiceUnavailableError
    V1SessionsUuidPlaybackStopPostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. 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. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StopPlaybackRequestBadRequestError
    StopPlaybackRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StopPlaybackRequestUnauthorizedError
    StopPlaybackRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StopPlaybackRequestNotFoundError
    StopPlaybackRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StopPlaybackRequestConflictError
    StopPlaybackRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StopPlaybackRequestContentTooLargeError
    StopPlaybackRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StopPlaybackRequestUnsupportedMediaTypeError
    StopPlaybackRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StopPlaybackRequestUnprocessableEntityError
    StopPlaybackRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StopPlaybackRequestTooManyRequestsError
    StopPlaybackRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPlaybackStopPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: StopPlaybackRequestServiceUnavailableError
    V1MediaStreamsOperationUuidSourcePostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the HTTP
        status and operation description, not just `code`, to distinguish them.
      title: V1MediaStreamsOperationUuidSourcePostResponsesContentApplicationJsonSchemaCode
    UploadPlaybackAudioRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1MediaStreamsOperationUuidSourcePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: UploadPlaybackAudioRequestBadRequestError
    UploadPlaybackAudioRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1MediaStreamsOperationUuidSourcePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: UploadPlaybackAudioRequestUnauthorizedError
    UploadPlaybackAudioRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1MediaStreamsOperationUuidSourcePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: UploadPlaybackAudioRequestNotFoundError
    UploadPlaybackAudioRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1MediaStreamsOperationUuidSourcePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: UploadPlaybackAudioRequestConflictError
    UploadPlaybackAudioRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1MediaStreamsOperationUuidSourcePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: UploadPlaybackAudioRequestUnsupportedMediaTypeError
    UploadPlaybackAudioRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1MediaStreamsOperationUuidSourcePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: UploadPlaybackAudioRequestTooManyRequestsError
    UploadPlaybackAudioRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1MediaStreamsOperationUuidSourcePostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: UploadPlaybackAudioRequestServiceUnavailableError
    V1SessionsUuidDtmfCollectPostRequestBodyContentApplicationJsonSchemaTerminatorsItems:
      type: string
      enum:
        - '#'
        - '*'
      title: V1SessionsUuidDtmfCollectPostRequestBodyContentApplicationJsonSchemaTerminatorsItems
    V1SessionsUuidDtmfCollectPostRequestBodyContentApplicationJsonSchemaValidation:
      type: object
      properties:
        regex:
          type: string
          maxLength: 256
          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: V1SessionsUuidDtmfCollectPostRequestBodyContentApplicationJsonSchemaValidation
    V1SessionsUuidDtmfCollectPostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the HTTP
        status and operation description, not just `code`, to distinguish them.
      title: V1SessionsUuidDtmfCollectPostResponsesContentApplicationJsonSchemaCode
    PlayPromptAndCollectDTMFDigitsRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidDtmfCollectPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: PlayPromptAndCollectDTMFDigitsRequestBadRequestError
    PlayPromptAndCollectDTMFDigitsRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidDtmfCollectPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: PlayPromptAndCollectDTMFDigitsRequestUnauthorizedError
    PlayPromptAndCollectDTMFDigitsRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidDtmfCollectPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: PlayPromptAndCollectDTMFDigitsRequestNotFoundError
    PlayPromptAndCollectDTMFDigitsRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidDtmfCollectPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: PlayPromptAndCollectDTMFDigitsRequestConflictError
    PlayPromptAndCollectDTMFDigitsRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidDtmfCollectPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: PlayPromptAndCollectDTMFDigitsRequestContentTooLargeError
    PlayPromptAndCollectDTMFDigitsRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidDtmfCollectPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: PlayPromptAndCollectDTMFDigitsRequestUnsupportedMediaTypeError
    PlayPromptAndCollectDTMFDigitsRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidDtmfCollectPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: PlayPromptAndCollectDTMFDigitsRequestUnprocessableEntityError
    PlayPromptAndCollectDTMFDigitsRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidDtmfCollectPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: PlayPromptAndCollectDTMFDigitsRequestTooManyRequestsError
    PlayPromptAndCollectDTMFDigitsRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidDtmfCollectPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: PlayPromptAndCollectDTMFDigitsRequestServiceUnavailableError
    V1SessionsUuidDtmfCollectDeleteResponsesContentApplicationJsonSchemaStatus:
      type: string
      enum:
        - cancelling
      title: V1SessionsUuidDtmfCollectDeleteResponsesContentApplicationJsonSchemaStatus
    Keypad Input_cancelPlayPromptAndCollectDTMFDigits_Response_202:
      type: object
      properties:
        operation_uuid:
          type: string
          format: uuid
        status:
          $ref: '#/components/schemas/V1SessionsUuidDtmfCollectDeleteResponsesContentApplicationJsonSchemaStatus'
      required:
        - operation_uuid
        - status
      description: >-
        An accepted asynchronous command. `operation_uuid` is an opaque correlation token for matching later lifecycle
        events; it does not name a resource.
      title: Keypad Input_cancelPlayPromptAndCollectDTMFDigits_Response_202
    V1SessionsUuidDtmfCollectDeleteResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the HTTP
        status and operation description, not just `code`, to distinguish them.
      title: V1SessionsUuidDtmfCollectDeleteResponsesContentApplicationJsonSchemaCode
    CancelPlayPromptAndCollectDTMFDigitsRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidDtmfCollectDeleteResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CancelPlayPromptAndCollectDTMFDigitsRequestBadRequestError
    CancelPlayPromptAndCollectDTMFDigitsRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidDtmfCollectDeleteResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CancelPlayPromptAndCollectDTMFDigitsRequestUnauthorizedError
    CancelPlayPromptAndCollectDTMFDigitsRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidDtmfCollectDeleteResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CancelPlayPromptAndCollectDTMFDigitsRequestNotFoundError
    CancelPlayPromptAndCollectDTMFDigitsRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidDtmfCollectDeleteResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CancelPlayPromptAndCollectDTMFDigitsRequestTooManyRequestsError
    V1SessionsUuidDtmfSendPostRequestBodyContentApplicationJsonSchemaSequenceItems0:
      type: object
      properties:
        digit:
          type: string
          pattern: ^[0-9A-D*#]$
          minLength: 1
          maxLength: 1
          description: 'The DTMF key to send: `0`-`9`, `A`-`D`, `*`, or `#`.'
        duration_ms:
          type: integer
          minimum: 50
          maximum: 2000
          description: Duration of this key press in milliseconds.
        type:
          type: string
          enum:
            - key
          description: Send one DTMF key press.
      required:
        - digit
        - duration_ms
        - type
      title: V1SessionsUuidDtmfSendPostRequestBodyContentApplicationJsonSchemaSequenceItems0
    V1SessionsUuidDtmfSendPostRequestBodyContentApplicationJsonSchemaSequenceItems1:
      type: object
      properties:
        duration_ms:
          type: integer
          minimum: 1
          maximum: 300000
          description: Requested wait in whole milliseconds; arbitrary values such as `1375` are accepted.
        type:
          type: string
          enum:
            - wait
          description: Wait before executing the next sequence action.
      required:
        - duration_ms
        - type
      title: V1SessionsUuidDtmfSendPostRequestBodyContentApplicationJsonSchemaSequenceItems1
    V1SessionsUuidDtmfSendPostRequestBodyContentApplicationJsonSchemaSequenceItems:
      oneOf:
        - $ref: '#/components/schemas/V1SessionsUuidDtmfSendPostRequestBodyContentApplicationJsonSchemaSequenceItems0'
        - $ref: '#/components/schemas/V1SessionsUuidDtmfSendPostRequestBodyContentApplicationJsonSchemaSequenceItems1'
      title: V1SessionsUuidDtmfSendPostRequestBodyContentApplicationJsonSchemaSequenceItems
    V1SessionsUuidDtmfSendPostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the HTTP
        status and operation description, not just `code`, to distinguish them.
      title: V1SessionsUuidDtmfSendPostResponsesContentApplicationJsonSchemaCode
    SendDTMFDigitsRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidDtmfSendPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: SendDTMFDigitsRequestBadRequestError
    SendDTMFDigitsRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidDtmfSendPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: SendDTMFDigitsRequestUnauthorizedError
    SendDTMFDigitsRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidDtmfSendPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: SendDTMFDigitsRequestNotFoundError
    SendDTMFDigitsRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidDtmfSendPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: SendDTMFDigitsRequestConflictError
    SendDTMFDigitsRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidDtmfSendPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: SendDTMFDigitsRequestContentTooLargeError
    SendDTMFDigitsRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidDtmfSendPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: SendDTMFDigitsRequestUnsupportedMediaTypeError
    SendDTMFDigitsRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidDtmfSendPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: SendDTMFDigitsRequestUnprocessableEntityError
    SendDTMFDigitsRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidDtmfSendPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: SendDTMFDigitsRequestTooManyRequestsError
    SendDTMFDigitsRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidDtmfSendPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: SendDTMFDigitsRequestServiceUnavailableError
    V1SessionsUuidDtmfSendDeleteResponsesContentApplicationJsonSchemaStatus:
      type: string
      enum:
        - cancelling
      title: V1SessionsUuidDtmfSendDeleteResponsesContentApplicationJsonSchemaStatus
    Keypad Input_cancelDTMFSend_Response_202:
      type: object
      properties:
        operation_uuid:
          type: string
          format: uuid
        status:
          $ref: '#/components/schemas/V1SessionsUuidDtmfSendDeleteResponsesContentApplicationJsonSchemaStatus'
      required:
        - operation_uuid
        - status
      description: >-
        An accepted asynchronous command. `operation_uuid` is an opaque correlation token for matching later lifecycle
        events; it does not name a resource.
      title: Keypad Input_cancelDTMFSend_Response_202
    V1SessionsUuidDtmfSendDeleteResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the HTTP
        status and operation description, not just `code`, to distinguish them.
      title: V1SessionsUuidDtmfSendDeleteResponsesContentApplicationJsonSchemaCode
    CancelDTMFSendRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidDtmfSendDeleteResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CancelDTMFSendRequestBadRequestError
    CancelDTMFSendRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidDtmfSendDeleteResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CancelDTMFSendRequestUnauthorizedError
    CancelDTMFSendRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidDtmfSendDeleteResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CancelDTMFSendRequestNotFoundError
    CancelDTMFSendRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidDtmfSendDeleteResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CancelDTMFSendRequestConflictError
    CancelDTMFSendRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidDtmfSendDeleteResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CancelDTMFSendRequestTooManyRequestsError
    CancelDTMFSendRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidDtmfSendDeleteResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CancelDTMFSendRequestServiceUnavailableError
    V1SessionsUuidPaymentCardCollectPostRequestBodyContentApplicationJsonSchemaTerminatorsItems:
      type: string
      enum:
        - '#'
        - '*'
      title: V1SessionsUuidPaymentCardCollectPostRequestBodyContentApplicationJsonSchemaTerminatorsItems
    V1SessionsUuidPaymentCardCollectPostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the HTTP
        status and operation description, not just `code`, to distinguish them.
      title: V1SessionsUuidPaymentCardCollectPostResponsesContentApplicationJsonSchemaCode
    CollectSecurePaymentCardRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPaymentCardCollectPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CollectSecurePaymentCardRequestBadRequestError
    CollectSecurePaymentCardRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPaymentCardCollectPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CollectSecurePaymentCardRequestUnauthorizedError
    CollectSecurePaymentCardRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPaymentCardCollectPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CollectSecurePaymentCardRequestNotFoundError
    CollectSecurePaymentCardRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPaymentCardCollectPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CollectSecurePaymentCardRequestConflictError
    CollectSecurePaymentCardRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPaymentCardCollectPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CollectSecurePaymentCardRequestContentTooLargeError
    CollectSecurePaymentCardRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPaymentCardCollectPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CollectSecurePaymentCardRequestUnsupportedMediaTypeError
    CollectSecurePaymentCardRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPaymentCardCollectPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CollectSecurePaymentCardRequestUnprocessableEntityError
    CollectSecurePaymentCardRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPaymentCardCollectPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CollectSecurePaymentCardRequestTooManyRequestsError
    CollectSecurePaymentCardRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPaymentCardCollectPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CollectSecurePaymentCardRequestServiceUnavailableError
    V1SessionsUuidPaymentCvvCollectPostRequestBodyContentApplicationJsonSchemaTerminatorsItems:
      type: string
      enum:
        - '#'
        - '*'
      title: V1SessionsUuidPaymentCvvCollectPostRequestBodyContentApplicationJsonSchemaTerminatorsItems
    V1SessionsUuidPaymentCvvCollectPostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the HTTP
        status and operation description, not just `code`, to distinguish them.
      title: V1SessionsUuidPaymentCvvCollectPostResponsesContentApplicationJsonSchemaCode
    CollectSecurePaymentCVVRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPaymentCvvCollectPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CollectSecurePaymentCVVRequestBadRequestError
    CollectSecurePaymentCVVRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPaymentCvvCollectPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CollectSecurePaymentCVVRequestUnauthorizedError
    CollectSecurePaymentCVVRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPaymentCvvCollectPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CollectSecurePaymentCVVRequestNotFoundError
    CollectSecurePaymentCVVRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPaymentCvvCollectPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CollectSecurePaymentCVVRequestConflictError
    CollectSecurePaymentCVVRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPaymentCvvCollectPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CollectSecurePaymentCVVRequestContentTooLargeError
    CollectSecurePaymentCVVRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPaymentCvvCollectPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CollectSecurePaymentCVVRequestUnsupportedMediaTypeError
    CollectSecurePaymentCVVRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPaymentCvvCollectPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CollectSecurePaymentCVVRequestUnprocessableEntityError
    CollectSecurePaymentCVVRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPaymentCvvCollectPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CollectSecurePaymentCVVRequestTooManyRequestsError
    CollectSecurePaymentCVVRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPaymentCvvCollectPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CollectSecurePaymentCVVRequestServiceUnavailableError
    V1SessionsUuidPaymentChargesPostRequestBodyContentApplicationJsonSchemaCurrency:
      type: string
      enum:
        - ils
      title: V1SessionsUuidPaymentChargesPostRequestBodyContentApplicationJsonSchemaCurrency
    V1SessionsUuidPaymentChargesPostRequestBodyContentApplicationJsonSchemaProvider:
      type: string
      enum:
        - nedarim
      title: V1SessionsUuidPaymentChargesPostRequestBodyContentApplicationJsonSchemaProvider
    V1SessionsUuidPaymentChargesPostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the HTTP
        status and operation description, not just `code`, to distinguish them.
      title: V1SessionsUuidPaymentChargesPostResponsesContentApplicationJsonSchemaCode
    CreateSecurePaymentChargeRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPaymentChargesPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CreateSecurePaymentChargeRequestBadRequestError
    CreateSecurePaymentChargeRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPaymentChargesPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CreateSecurePaymentChargeRequestUnauthorizedError
    CreateSecurePaymentChargeRequestForbiddenError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPaymentChargesPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CreateSecurePaymentChargeRequestForbiddenError
    CreateSecurePaymentChargeRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPaymentChargesPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CreateSecurePaymentChargeRequestNotFoundError
    CreateSecurePaymentChargeRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPaymentChargesPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CreateSecurePaymentChargeRequestConflictError
    CreateSecurePaymentChargeRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPaymentChargesPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CreateSecurePaymentChargeRequestContentTooLargeError
    CreateSecurePaymentChargeRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPaymentChargesPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CreateSecurePaymentChargeRequestUnsupportedMediaTypeError
    CreateSecurePaymentChargeRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPaymentChargesPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CreateSecurePaymentChargeRequestUnprocessableEntityError
    CreateSecurePaymentChargeRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPaymentChargesPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CreateSecurePaymentChargeRequestTooManyRequestsError
    CreateSecurePaymentChargeRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1SessionsUuidPaymentChargesPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CreateSecurePaymentChargeRequestServiceUnavailableError
    V1MessagesGetResponsesContentApplicationJsonSchemaMessagesItemsChannel:
      type: string
      enum:
        - sms
      title: V1MessagesGetResponsesContentApplicationJsonSchemaMessagesItemsChannel
    V1MessagesGetResponsesContentApplicationJsonSchemaMessagesItemsContentType:
      type: string
      enum:
        - text
      title: V1MessagesGetResponsesContentApplicationJsonSchemaMessagesItemsContentType
    V1MessagesGetResponsesContentApplicationJsonSchemaMessagesItemsContent:
      type: object
      properties:
        text:
          type: string
          minLength: 1
          maxLength: 1600
        type:
          $ref: '#/components/schemas/V1MessagesGetResponsesContentApplicationJsonSchemaMessagesItemsContentType'
      required:
        - text
        - type
      title: V1MessagesGetResponsesContentApplicationJsonSchemaMessagesItemsContent
    V1MessagesGetResponsesContentApplicationJsonSchemaMessagesItemsDeliveryStatus:
      type: string
      enum:
        - pending
        - delivered
        - failed
        - unknown
      description: >-
        Platform knowledge of recipient delivery. `unknown` means monitoring ended without a conclusive outcome; it does
        not mean delivery failed.
      title: V1MessagesGetResponsesContentApplicationJsonSchemaMessagesItemsDeliveryStatus
    V1MessagesGetResponsesContentApplicationJsonSchemaMessagesItemsDirection:
      type: string
      enum:
        - outbound
      title: V1MessagesGetResponsesContentApplicationJsonSchemaMessagesItemsDirection
    V1MessagesGetResponsesContentApplicationJsonSchemaMessagesItemsSendingStatus:
      type: string
      enum:
        - queued
        - sent
      description: Latest confirmed outbound sending milestone. This field is independent of recipient delivery.
      title: V1MessagesGetResponsesContentApplicationJsonSchemaMessagesItemsSendingStatus
    V1MessagesGetResponsesContentApplicationJsonSchemaMessagesItems:
      type: object
      properties:
        channel:
          $ref: '#/components/schemas/V1MessagesGetResponsesContentApplicationJsonSchemaMessagesItemsChannel'
        content:
          $ref: '#/components/schemas/V1MessagesGetResponsesContentApplicationJsonSchemaMessagesItemsContent'
        created_at:
          type: string
          format: date-time
        delivery_status:
          $ref: '#/components/schemas/V1MessagesGetResponsesContentApplicationJsonSchemaMessagesItemsDeliveryStatus'
          description: >-
            Platform knowledge of recipient delivery. `unknown` means monitoring ended without a conclusive outcome; it
            does not mean delivery failed.
        direction:
          $ref: '#/components/schemas/V1MessagesGetResponsesContentApplicationJsonSchemaMessagesItemsDirection'
        from:
          type: string
        message_uuid:
          type: string
          pattern: ^msg_[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
        sending_status:
          $ref: '#/components/schemas/V1MessagesGetResponsesContentApplicationJsonSchemaMessagesItemsSendingStatus'
          description: Latest confirmed outbound sending milestone. This field is independent of recipient delivery.
        to:
          type: string
          pattern: ^\+[1-9]\d{1,14}$
        updated_at:
          type: string
          format: date-time
      required:
        - channel
        - content
        - created_at
        - delivery_status
        - direction
        - from
        - message_uuid
        - sending_status
        - to
        - updated_at
      title: V1MessagesGetResponsesContentApplicationJsonSchemaMessagesItems
    Messages_listMessages_Response_200:
      type: object
      properties:
        messages:
          type: array
          items:
            $ref: '#/components/schemas/V1MessagesGetResponsesContentApplicationJsonSchemaMessagesItems'
      required:
        - messages
      title: Messages_listMessages_Response_200
    V1MessagesGetResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the HTTP
        status and operation description, not just `code`, to distinguish them.
      title: V1MessagesGetResponsesContentApplicationJsonSchemaCode
    ListMessagesRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1MessagesGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: ListMessagesRequestBadRequestError
    ListMessagesRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1MessagesGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: ListMessagesRequestUnauthorizedError
    ListMessagesRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1MessagesGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: ListMessagesRequestContentTooLargeError
    ListMessagesRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1MessagesGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: ListMessagesRequestServiceUnavailableError
    V1MessagesPostRequestBodyContentApplicationJsonSchemaChannel:
      type: string
      enum:
        - sms
      title: V1MessagesPostRequestBodyContentApplicationJsonSchemaChannel
    V1MessagesPostRequestBodyContentApplicationJsonSchemaContentType:
      type: string
      enum:
        - text
      title: V1MessagesPostRequestBodyContentApplicationJsonSchemaContentType
    V1MessagesPostRequestBodyContentApplicationJsonSchemaContent:
      type: object
      properties:
        text:
          type: string
          minLength: 1
          maxLength: 1600
        type:
          $ref: '#/components/schemas/V1MessagesPostRequestBodyContentApplicationJsonSchemaContentType'
      required:
        - text
        - type
      title: V1MessagesPostRequestBodyContentApplicationJsonSchemaContent
    V1MessagesPostResponsesContentApplicationJsonSchemaChannel:
      type: string
      enum:
        - sms
      title: V1MessagesPostResponsesContentApplicationJsonSchemaChannel
    V1MessagesPostResponsesContentApplicationJsonSchemaDeliveryStatus:
      type: string
      enum:
        - pending
      description: >-
        Platform knowledge of recipient delivery. `pending` means the monitoring window remains open without a
        conclusive outcome.
      title: V1MessagesPostResponsesContentApplicationJsonSchemaDeliveryStatus
    V1MessagesPostResponsesContentApplicationJsonSchemaDirection:
      type: string
      enum:
        - outbound
      title: V1MessagesPostResponsesContentApplicationJsonSchemaDirection
    V1MessagesPostResponsesContentApplicationJsonSchemaSendingStatus:
      type: string
      enum:
        - queued
      description: Latest confirmed outbound sending milestone. `queued` means the provider accepted the message into its queue.
      title: V1MessagesPostResponsesContentApplicationJsonSchemaSendingStatus
    SMS Messages_createMessage_Response_202:
      type: object
      properties:
        channel:
          $ref: '#/components/schemas/V1MessagesPostResponsesContentApplicationJsonSchemaChannel'
        created_at:
          type: string
          format: date-time
        delivery_status:
          $ref: '#/components/schemas/V1MessagesPostResponsesContentApplicationJsonSchemaDeliveryStatus'
          description: >-
            Platform knowledge of recipient delivery. `pending` means the monitoring window remains open without a
            conclusive outcome.
        direction:
          $ref: '#/components/schemas/V1MessagesPostResponsesContentApplicationJsonSchemaDirection'
        message_uuid:
          type: string
          pattern: ^msg_[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
        sending_status:
          $ref: '#/components/schemas/V1MessagesPostResponsesContentApplicationJsonSchemaSendingStatus'
          description: >-
            Latest confirmed outbound sending milestone. `queued` means the provider accepted the message into its
            queue.
      required:
        - channel
        - created_at
        - delivery_status
        - direction
        - message_uuid
        - sending_status
      title: SMS Messages_createMessage_Response_202
    V1MessagesPostResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the HTTP
        status and operation description, not just `code`, to distinguish them.
      title: V1MessagesPostResponsesContentApplicationJsonSchemaCode
    CreateMessageRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1MessagesPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CreateMessageRequestBadRequestError
    CreateMessageRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1MessagesPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CreateMessageRequestUnauthorizedError
    CreateMessageRequestForbiddenError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1MessagesPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CreateMessageRequestForbiddenError
    CreateMessageRequestConflictError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1MessagesPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CreateMessageRequestConflictError
    CreateMessageRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1MessagesPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CreateMessageRequestContentTooLargeError
    CreateMessageRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1MessagesPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CreateMessageRequestUnsupportedMediaTypeError
    CreateMessageRequestUnprocessableEntityError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1MessagesPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CreateMessageRequestUnprocessableEntityError
    CreateMessageRequestTooManyRequestsError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1MessagesPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CreateMessageRequestTooManyRequestsError
    CreateMessageRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1MessagesPostResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: CreateMessageRequestServiceUnavailableError
    V1MessagesMessageUuidGetResponsesContentApplicationJsonSchemaChannel:
      type: string
      enum:
        - sms
      title: V1MessagesMessageUuidGetResponsesContentApplicationJsonSchemaChannel
    V1MessagesMessageUuidGetResponsesContentApplicationJsonSchemaContentType:
      type: string
      enum:
        - text
      title: V1MessagesMessageUuidGetResponsesContentApplicationJsonSchemaContentType
    V1MessagesMessageUuidGetResponsesContentApplicationJsonSchemaContent:
      type: object
      properties:
        text:
          type: string
          minLength: 1
          maxLength: 1600
        type:
          $ref: '#/components/schemas/V1MessagesMessageUuidGetResponsesContentApplicationJsonSchemaContentType'
      required:
        - text
        - type
      title: V1MessagesMessageUuidGetResponsesContentApplicationJsonSchemaContent
    V1MessagesMessageUuidGetResponsesContentApplicationJsonSchemaDeliveryStatus:
      type: string
      enum:
        - pending
        - delivered
        - failed
        - unknown
      description: >-
        Platform knowledge of recipient delivery. `unknown` means monitoring ended without a conclusive outcome; it does
        not mean delivery failed.
      title: V1MessagesMessageUuidGetResponsesContentApplicationJsonSchemaDeliveryStatus
    V1MessagesMessageUuidGetResponsesContentApplicationJsonSchemaDirection:
      type: string
      enum:
        - outbound
      title: V1MessagesMessageUuidGetResponsesContentApplicationJsonSchemaDirection
    V1MessagesMessageUuidGetResponsesContentApplicationJsonSchemaSendingStatus:
      type: string
      enum:
        - queued
        - sent
      description: Latest confirmed outbound sending milestone. This field is independent of recipient delivery.
      title: V1MessagesMessageUuidGetResponsesContentApplicationJsonSchemaSendingStatus
    SMS Messages_getMessageStatus_Response_200:
      type: object
      properties:
        channel:
          $ref: '#/components/schemas/V1MessagesMessageUuidGetResponsesContentApplicationJsonSchemaChannel'
        content:
          $ref: '#/components/schemas/V1MessagesMessageUuidGetResponsesContentApplicationJsonSchemaContent'
        created_at:
          type: string
          format: date-time
        delivery_status:
          $ref: '#/components/schemas/V1MessagesMessageUuidGetResponsesContentApplicationJsonSchemaDeliveryStatus'
          description: >-
            Platform knowledge of recipient delivery. `unknown` means monitoring ended without a conclusive outcome; it
            does not mean delivery failed.
        direction:
          $ref: '#/components/schemas/V1MessagesMessageUuidGetResponsesContentApplicationJsonSchemaDirection'
        from:
          type: string
        message_uuid:
          type: string
          pattern: ^msg_[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
        sending_status:
          $ref: '#/components/schemas/V1MessagesMessageUuidGetResponsesContentApplicationJsonSchemaSendingStatus'
          description: Latest confirmed outbound sending milestone. This field is independent of recipient delivery.
        to:
          type: string
          pattern: ^\+[1-9]\d{1,14}$
        updated_at:
          type: string
          format: date-time
      required:
        - channel
        - content
        - created_at
        - delivery_status
        - direction
        - from
        - message_uuid
        - sending_status
        - to
        - updated_at
      title: SMS Messages_getMessageStatus_Response_200
    V1MessagesMessageUuidGetResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the HTTP
        status and operation description, not just `code`, to distinguish them.
      title: V1MessagesMessageUuidGetResponsesContentApplicationJsonSchemaCode
    GetMessageStatusRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1MessagesMessageUuidGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: GetMessageStatusRequestBadRequestError
    GetMessageStatusRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1MessagesMessageUuidGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: GetMessageStatusRequestUnauthorizedError
    GetMessageStatusRequestNotFoundError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1MessagesMessageUuidGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: GetMessageStatusRequestNotFoundError
    GetMessageStatusRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/V1MessagesMessageUuidGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: GetMessageStatusRequestServiceUnavailableError
    AppConfigurationResponseBlockedWebhookEventsItems:
      type: string
      enum:
        - session.created
        - session.answered
        - session.ended
        - session.ringing_started
        - session.early_media_started
        - session.held
        - session.resumed
        - dtmf.received
        - digits.collected
        - payment.card.collected
        - payment.cvv.collected
        - payment.charge.completed
        - playback.started
        - playback.stopped
        - playback.failed
        - recording.became_available
        - recording.ended
        - recording.failed
        - recording.speech.started
        - recording.speech.ended
        - room.created
        - room.deleted
        - room.member.joined
        - room.member.left
        - room.member.muted
        - room.member.unmuted
        - room.member.volume_changed
        - room.member.volume_change_failed
        - room.member.voice_activity_changed
        - room.playback.ended
        - room.playback.failed
        - message.queued
        - message.sent
        - message.delivery_status
        - websocket.connected
        - websocket.disconnected
        - websocket.failed
        - websocket.audio_playback_completed
      title: AppConfigurationResponseBlockedWebhookEventsItems
    AppConfigurationResponseLimits:
      type: object
      properties:
        max_members_per_room:
          type:
            - integer
            - 'null'
          minimum: 1
          description: Maximum number of members in one room, or null when rooms have no member cap.
        max_rooms:
          type: integer
          minimum: 1
          description: Maximum number of rooms that the application can have at the same time.
      required:
        - max_members_per_room
        - max_rooms
      title: AppConfigurationResponseLimits
    AppConfigurationResponse:
      type: object
      properties:
        app_uuid:
          type: string
          pattern: ^app_[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
          description: Identifier of the authenticated application.
        blocked_webhook_events:
          type: array
          items:
            $ref: '#/components/schemas/AppConfigurationResponseBlockedWebhookEventsItems'
          description: Event types excluded from webhook delivery. An empty array means all event types are delivered.
        inbound_phone_numbers:
          type: array
          items:
            type: string
            pattern: ^\+[1-9]\d{1,14}$
          description: >-
            Inbound phone numbers assigned to this application, sorted in ascending canonical E.164 order. Assignment
            changes can take time to reach call routing.
        limits:
          $ref: '#/components/schemas/AppConfigurationResponseLimits'
        outbound_caller_ids:
          type: array
          items:
            type: string
            pattern: ^\+[1-9]\d{1,14}$
          description: >-
            Phone numbers this application can present as caller ID on outbound calls, sorted in ascending canonical
            E.164 order.
        sms_identities:
          type: array
          items:
            type: string
            pattern: ^(\+[1-9][0-9]{1,14}|[A-Za-z]{1,11})$
            minLength: 1
            maxLength: 16
          description: >-
            Exact, case-sensitive SMS identities this application may present to recipients, sorted by stored value. An
            empty array means outbound SMS is disabled.
        webhook_url:
          type:
            - string
            - 'null'
          description: Webhook delivery URL, or null when webhook delivery is disabled.
      required:
        - app_uuid
        - blocked_webhook_events
        - inbound_phone_numbers
        - limits
        - outbound_caller_ids
        - sms_identities
        - webhook_url
      title: AppConfigurationResponse
    ApiV1AppGetResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the HTTP
        status and operation description, not just `code`, to distinguish them.
      title: ApiV1AppGetResponsesContentApplicationJsonSchemaCode
    GetApplicationConfigurationRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1AppGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: GetApplicationConfigurationRequestUnauthorizedError
    GetApplicationConfigurationRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1AppGetResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: GetApplicationConfigurationRequestServiceUnavailableError
    AppConfigurationPatchRequest:
      type: object
      properties:
        webhook_url:
          type:
            - string
            - 'null'
          description: >-
            HTTP or HTTPS webhook delivery URL. HTTPS is recommended because HTTP does not provide transport encryption.
            Set to null or an empty string to disable webhook delivery.
      title: AppConfigurationPatchRequest
    ApiV1AppPatchResponsesContentApplicationJsonSchemaCode:
      type: string
      enum:
        - invalid_request
        - invalid_authorization_header
        - payload_too_large
        - result_set_too_large
        - unauthorized
        - forbidden
        - not_found
        - conflict
        - recording_not_active
        - room_full
        - rate_limited
        - unavailable
      description: >-
        Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes are
        only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
        (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large` (413),
        `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict` and
        `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the separate
        `InternalErrorResponse` schema.


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


        Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means a
        required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the HTTP
        status and operation description, not just `code`, to distinguish them.
      title: ApiV1AppPatchResponsesContentApplicationJsonSchemaCode
    UpdateApplicationConfigurationRequestBadRequestError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1AppPatchResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: UpdateApplicationConfigurationRequestBadRequestError
    UpdateApplicationConfigurationRequestUnauthorizedError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1AppPatchResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: UpdateApplicationConfigurationRequestUnauthorizedError
    UpdateApplicationConfigurationRequestContentTooLargeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1AppPatchResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: UpdateApplicationConfigurationRequestContentTooLargeError
    UpdateApplicationConfigurationRequestUnsupportedMediaTypeError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1AppPatchResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: UpdateApplicationConfigurationRequestUnsupportedMediaTypeError
    UpdateApplicationConfigurationRequestServiceUnavailableError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ApiV1AppPatchResponsesContentApplicationJsonSchemaCode'
          description: >-
            Stable, machine-readable error class from a closed set. Branch on this for programmatic handling. New codes
            are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request`
            (400/405/415/422), `invalid_authorization_header` (400), `payload_too_large` and `result_set_too_large`
            (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (409); `conflict`
            and `room_full` (409), `rate_limited` (429), and `unavailable` (503/529). Unexpected failures use the
            separate `InternalErrorResponse` schema.


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


            Note: `unavailable` maps to multiple HTTP statuses, which represent different retry conditions: `503` means
            a required store or service is temporarily unavailable, and `529` means the platform is overloaded. Use the
            HTTP status and operation description, not just `code`, to distinguish them.
        message:
          type: string
          description: >-
            Human-readable, English-only error message. For display only — phrasing may change without notice, so branch
            on `code`, not on this string.
      required:
        - code
        - message
      title: UpdateApplicationConfigurationRequestServiceUnavailableError
    HealthGetResponsesContentApplicationJsonSchemaStatus:
      type: string
      enum:
        - degraded
      title: HealthGetResponsesContentApplicationJsonSchemaStatus
    Health_check_Response_200:
      type: object
      properties:
        status:
          $ref: '#/components/schemas/HealthGetResponsesContentApplicationJsonSchemaStatus'
      required:
        - status
      title: Health_check_Response_200
    HealthCheckRequestServiceUnavailableError:
      type: object
      properties:
        status:
          $ref: '#/components/schemas/HealthGetResponsesContentApplicationJsonSchemaStatus'
      required:
        - 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>` using any active key in the app's
        collection. See [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for details.
