> ## Documentation Index
> Fetch the complete documentation index at: https://docs.textql.com/llms.txt
> Use this file to discover all available pages before exploring further.

# List Patches



## OpenAPI

````yaml api-reference/speakeasy/textql-api-with-code-samples.yaml POST /textql.rpc.public.patches.OntologyManagementService/ListPatches
openapi: 3.1.0
info:
  title: TextQL API
  version: 1.0.0
  description: |
    TextQL public API. Generated from protobuf service definitions; internal
    endpoints are excluded via google.api.visibility / file_visibility.
servers:
  - url: https://app.textql.com
security:
  - apiKey: []
tags:
  - name: DashboardService
  - name: AppService
    description: |-
      AppService manages data apps: the generative app execution primitive.
       An app is agent-authored single-file HTML/JS/CSS executing in a CSP sandbox,
       fed a snapshot of its declared data sources. First-class resource, not a dashboard.
  - name: ConnectorService
  - name: PowerBIService
  - name: TableauService
  - name: DatasetService
  - name: OntologyManagementService
  - name: ChatService
  - name: AgentService
  - name: AuditLogService
  - name: MCPService
  - name: MetricsExportService
  - name: ObservabilityService
  - name: PlaybookService
  - name: RBACService
    description: RBAC service for managing roles, permissions, and access control
  - name: SandboxAdminService
  - name: SandboxQueryService
  - name: SandboxCapabilityService
  - name: ScimService
  - name: SecretService
  - name: SlackService
  - name: TeamsService
paths:
  /textql.rpc.public.patches.OntologyManagementService/ListPatches:
    post:
      tags:
        - OntologyManagementService
      summary: ListPatches
      operationId: OntologyManagementService_ListPatches
      parameters:
        - name: Connect-Protocol-Version
          in: header
          required: true
          schema:
            $ref: '#/components/schemas/connect-protocol-version'
        - name: Connect-Timeout-Ms
          in: header
          schema:
            $ref: '#/components/schemas/connect-timeout-header'
      requestBody:
        content:
          application/json:
            schema:
              $ref: >-
                #/components/schemas/textql.rpc.public.patches.ListPatchesRequest
        required: true
      responses:
        '200':
          description: Success
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/textql.rpc.public.patches.ListPatchesResponse
        default:
          description: Error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/connect.error'
      x-codeSamples:
        - lang: python
          label: Python (SDK)
          source: |-
            import os
            from textql_sdk import Textql


            with Textql(
                api_key=os.getenv("TEXTQL_API_KEY", ""),
            ) as textql:

                res = textql.ontology_management_service.ontology_management_service_list_patches()

                # Handle response
                print(res)
        - lang: typescript
          label: TypeScript (SDK)
          source: |-
            import { Textql } from "@textql/sdk";

            const textql = new Textql({
              apiKey: process.env["TEXTQL_API_KEY"] ?? "",
            });

            async function run() {
              const result = await textql.ontologyManagementService.ontologyManagementServiceListPatches({
                body: {},
              });

              console.log(result);
            }

            run();
components:
  schemas:
    connect-protocol-version:
      type: number
      title: Connect-Protocol-Version
      enum:
        - 1
      description: Define the version of the Connect protocol
      const: 1
      default: 1
    connect-timeout-header:
      type: number
      title: Connect-Timeout-Ms
      description: Define the timeout, in ms
    textql.rpc.public.patches.ListPatchesRequest:
      type: object
      properties:
        pageSize:
          type: integer
          title: page_size
          format: int32
          nullable: true
        pageToken:
          type: string
          title: page_token
          nullable: true
        statuses:
          type: array
          items:
            $ref: '#/components/schemas/textql.rpc.public.patches.PatchStatus'
          title: statuses
        includeAutoApproved:
          type: boolean
          title: include_auto_approved
          nullable: true
      title: ListPatchesRequest
      additionalProperties: false
    textql.rpc.public.patches.ListPatchesResponse:
      type: object
      properties:
        patches:
          type: array
          items:
            $ref: '#/components/schemas/textql.rpc.public.patches.Patch'
          title: patches
        nextPageToken:
          type: string
          title: next_page_token
          nullable: true
        counts:
          $ref: '#/components/schemas/textql.rpc.public.patches.PatchStatusCounts'
          title: counts
          nullable: true
      title: ListPatchesResponse
      additionalProperties: false
    connect.error:
      type: object
      properties:
        code:
          type: string
          examples:
            - not_found
          enum:
            - canceled
            - unknown
            - invalid_argument
            - deadline_exceeded
            - not_found
            - already_exists
            - permission_denied
            - resource_exhausted
            - failed_precondition
            - aborted
            - out_of_range
            - unimplemented
            - internal
            - unavailable
            - data_loss
            - unauthenticated
          description: >-
            The status code, which should be an enum value of
            [google.rpc.Code][google.rpc.Code].
        message:
          type: string
          description: >-
            A developer-facing error message, which should be in English. Any
            user-facing error message should be localized and sent in the
            [google.rpc.Status.details][google.rpc.Status.details] field, or
            localized by the client.
        details:
          type: array
          items:
            $ref: '#/components/schemas/connect.error_details.Any'
          description: >-
            A list of messages that carry the error details. There is no limit
            on the number of messages.
      title: Connect Error
      additionalProperties: true
      description: >-
        Error type returned by Connect:
        https://connectrpc.com/docs/go/errors/#http-representation
    textql.rpc.public.patches.PatchStatus:
      type: string
      title: PatchStatus
      enum:
        - PATCH_STATUS_UNKNOWN
        - PATCH_STATUS_RESERVED
        - PATCH_STATUS_DRAFT
        - PATCH_STATUS_OPEN
        - PATCH_STATUS_APPROVED
        - PATCH_STATUS_DENIED
    textql.rpc.public.patches.Patch:
      type: object
      properties:
        id:
          type: string
          title: id
        number:
          type: integer
          title: number
          format: int32
        authorId:
          type: string
          title: author_id
        title:
          type: string
          title: title
        description:
          type: string
          title: description
        chatId:
          type: string
          title: chat_id
          nullable: true
        aiGenerated:
          type: boolean
          title: ai_generated
        diffs:
          type: array
          items:
            $ref: '#/components/schemas/textql.rpc.public.patches.PatchDiff'
          title: diffs
        status:
          $ref: '#/components/schemas/textql.rpc.public.patches.PatchStatus'
          title: status
        gitRef:
          type: string
          title: git_ref
        revision:
          type: integer
          title: revision
          format: int32
        headAtMerge:
          type: string
          title: head_at_merge
          description: for showing diffs post-merge
          nullable: true
        reviewerId:
          type: string
          title: reviewer_id
          description: for auditing reviews
          nullable: true
        createdAt:
          $ref: '#/components/schemas/google.protobuf.Timestamp'
          title: created_at
        updatedAt:
          $ref: '#/components/schemas/google.protobuf.Timestamp'
          title: updated_at
        authorEmail:
          type: string
          title: author_email
          nullable: true
        authorName:
          type: string
          title: author_name
          nullable: true
        approvalCount:
          type: integer
          title: approval_count
          format: int32
        requiredApprovals:
          type: integer
          title: required_approvals
          format: int32
        capabilities:
          $ref: '#/components/schemas/textql.rpc.public.patches.PatchCapabilities'
          title: capabilities
          description: >-
            capabilities is populated for open patches in ListPatches so the UI
            can
             render only the action buttons the caller is permitted to use. Nil for
             non-open patches (no actions are available) and for endpoints that don't
             compute it.
          nullable: true
        codeOwnerStatus:
          type: array
          items:
            $ref: >-
              #/components/schemas/textql.rpc.public.patches.PatchCodeownerStatus
          title: code_owner_status
        requestedReviewerMemberIds:
          type: array
          items:
            type: string
          title: requested_reviewer_member_ids
      title: Patch
      additionalProperties: false
    textql.rpc.public.patches.PatchStatusCounts:
      type: object
      properties:
        open:
          type: integer
          title: open
          format: int32
        draftMine:
          type: integer
          title: draft_mine
          format: int32
        approved:
          type: integer
          title: approved
          format: int32
        denied:
          type: integer
          title: denied
          format: int32
        openMine:
          type: integer
          title: open_mine
          format: int32
      title: PatchStatusCounts
      additionalProperties: false
    connect.error_details.Any:
      type: object
      properties:
        type:
          type: string
          description: >-
            A URL that acts as a globally unique identifier for the type of the
            serialized message. For example:
            `type.googleapis.com/google.rpc.ErrorInfo`. This is used to
            determine the schema of the data in the `value` field and is the
            discriminator for the `debug` field.
        value:
          type: string
          format: binary
          description: >-
            The Protobuf message, serialized as bytes and base64-encoded. The
            specific message type is identified by the `type` field.
        debug:
          oneOf:
            - type: object
              title: Any
              additionalProperties: true
              description: Detailed error information.
          discriminator:
            propertyName: type
          title: Debug
          description: >-
            Deserialized error detail payload. The 'type' field indicates the
            schema. This field is for easier debugging and should not be relied
            upon for application logic.
      additionalProperties: true
      description: >-
        Contains an arbitrary serialized message along with a @type that
        describes the type of the serialized message, with an additional debug
        field for ConnectRPC error details.
    textql.rpc.public.patches.PatchDiff:
      type: object
      properties:
        name:
          type: string
          title: name
        oldPath:
          type: string
          title: old_path
        newPath:
          type: string
          title: new_path
        hunks:
          type: array
          items:
            $ref: '#/components/schemas/textql.rpc.public.patches.PatchHunk'
          title: hunks
        additions:
          type:
            - integer
            - string
          title: additions
          format: int64
        deletions:
          type:
            - integer
            - string
          title: deletions
          format: int64
        isBinary:
          type: boolean
          title: is_binary
        isNew:
          type: boolean
          title: is_new
        isCopy:
          type: boolean
          title: is_copy
        isRename:
          type: boolean
          title: is_rename
        isDelete:
          type: boolean
          title: is_delete
        oldContent:
          type: string
          title: old_content
          description: 'optional: provide full file content for easy navigation'
          nullable: true
        newContent:
          type: string
          title: new_content
          nullable: true
      title: PatchDiff
      additionalProperties: false
    google.protobuf.Timestamp:
      type: string
      examples:
        - '2023-01-15T01:30:15.01Z'
        - '2024-12-25T12:00:00Z'
      format: date-time
      description: >-
        A Timestamp represents a point in time independent of any time zone or
        local
         calendar, encoded as a count of seconds and fractions of seconds at
         nanosecond resolution. The count is relative to an epoch at UTC midnight on
         January 1, 1970, in the proleptic Gregorian calendar which extends the
         Gregorian calendar backwards to year one.

         All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
         second table is needed for interpretation, using a [24-hour linear
         smear](https://developers.google.com/time/smear).

         The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
         restricting to that range, we ensure that we can convert to and from [RFC
         3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.

         # Examples

         Example 1: Compute Timestamp from POSIX `time()`.

             Timestamp timestamp;
             timestamp.set_seconds(time(NULL));
             timestamp.set_nanos(0);

         Example 2: Compute Timestamp from POSIX `gettimeofday()`.

             struct timeval tv;
             gettimeofday(&tv, NULL);

             Timestamp timestamp;
             timestamp.set_seconds(tv.tv_sec);
             timestamp.set_nanos(tv.tv_usec * 1000);

         Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.

             FILETIME ft;
             GetSystemTimeAsFileTime(&ft);
             UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;

             // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
             // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
             Timestamp timestamp;
             timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
             timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));

         Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.

             long millis = System.currentTimeMillis();

             Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
                 .setNanos((int) ((millis % 1000) * 1000000)).build();

         Example 5: Compute Timestamp from Java `Instant.now()`.

             Instant now = Instant.now();

             Timestamp timestamp =
                 Timestamp.newBuilder().setSeconds(now.getEpochSecond())
                     .setNanos(now.getNano()).build();

         Example 6: Compute Timestamp from current time in Python.

             timestamp = Timestamp()
             timestamp.GetCurrentTime()

         # JSON Mapping

         In JSON format, the Timestamp type is encoded as a string in the
         [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
         format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
         where {year} is always expressed using four digits while {month}, {day},
         {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
         seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
         are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
         is required. A proto3 JSON serializer should always use UTC (as indicated by
         "Z") when printing the Timestamp type and a proto3 JSON parser should be
         able to accept both UTC and other timezones (as indicated by an offset).

         For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
         01:30 UTC on January 15, 2017.

         In JavaScript, one can convert a Date object to this format using the
         standard
         [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
         method. In Python, a standard `datetime.datetime` object can be converted
         to this format using
         [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
         the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
         the Joda Time's [`ISODateTimeFormat.dateTime()`](
         http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()
         ) to obtain a formatter capable of generating timestamps in this format.
    textql.rpc.public.patches.PatchCapabilities:
      type: object
      properties:
        canApprove:
          type: boolean
          title: can_approve
        canDeny:
          type: boolean
          title: can_deny
        canRestore:
          type: boolean
          title: can_restore
        callerApproved:
          type: boolean
          title: caller_approved
      title: PatchCapabilities
      additionalProperties: false
      description: |-
        PatchCapabilities describes which patch actions the calling member is
         permitted to perform. This is a read-only mirror of the authority checks in
         ApprovePatch and DenyPatch; computing it has no side effects and emits no
         audit log.
    textql.rpc.public.patches.PatchCodeownerStatus:
      type: object
      properties:
        pattern:
          type: string
          title: pattern
        ownerMemberIds:
          type: array
          items:
            type: string
          title: owner_member_ids
        requireApprovals:
          type: integer
          title: require_approvals
          format: int32
        approvalCount:
          type: integer
          title: approval_count
          format: int32
        satisfied:
          type: boolean
          title: satisfied
      title: PatchCodeownerStatus
      additionalProperties: false
    textql.rpc.public.patches.PatchHunk:
      type: object
      properties:
        comment:
          type: string
          title: comment
        oldPosition:
          type:
            - integer
            - string
          title: old_position
          format: int64
        oldLines:
          type:
            - integer
            - string
          title: old_lines
          format: int64
        newPosition:
          type:
            - integer
            - string
          title: new_position
          format: int64
        newLines:
          type:
            - integer
            - string
          title: new_lines
          format: int64
        linesAdded:
          type:
            - integer
            - string
          title: lines_added
          format: int64
        linesDeleted:
          type:
            - integer
            - string
          title: lines_deleted
          format: int64
        leadingContext:
          type:
            - integer
            - string
          title: leading_context
          format: int64
        trailingContext:
          type:
            - integer
            - string
          title: trailing_context
          format: int64
        lines:
          type: array
          items:
            $ref: '#/components/schemas/textql.rpc.public.patches.PatchLine'
          title: lines
      title: PatchHunk
      additionalProperties: false
    textql.rpc.public.patches.PatchLine:
      type: object
      properties:
        op:
          $ref: '#/components/schemas/textql.rpc.public.patches.PatchLineOp'
          title: op
        line:
          type: string
          title: line
      title: PatchLine
      additionalProperties: false
    textql.rpc.public.patches.PatchLineOp:
      type: string
      title: PatchLineOp
      enum:
        - PATCH_LINE_OP_CONTEXT
        - PATCH_LINE_OP_DELETE
        - PATCH_LINE_OP_ADD
  securitySchemes:
    apiKey:
      type: apiKey
      in: header
      name: tql_api_key

````