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

# Get a verification run

> Returns one merge-queue verification run, including its normalized CI checks, the pull requests it tested, and the impacted targets uploaded for its commits.



## OpenAPI

````yaml /openapi-v2.json get /v2/merge-queue-verification-runs/{id}
openapi: 3.1.0
info:
  title: Trunk API
  version: 2.0.0
  description: >-
    The Trunk public API. Every endpoint is scoped to a single organization and
    requires a credential.


    ## Authentication


    For automation, send an API key as `Authorization: Bearer <key>`. An
    organization admin creates one in the Trunk app under **Settings → Developer
    → API Keys**, and chooses the permissions it holds. A new key starts with no
    permissions: it can read merge queues but change nothing in them, and it
    cannot get a Dynamic CI plan. Each endpoint that needs a permission names it
    in its description; the Dynamic CI plan endpoints need **Generate Dynamic CI
    plans**.


    A short-lived token in the `x-trunk-token` header is what Trunk's own tools
    send, such as the `trunk` CLI after `trunk auth login`. Your own
    integrations should use an API key.


    A GitHub Actions job can upload and read impacted targets with no Trunk
    secret: the `trunk-io/login` action exchanges the run's own GitHub
    credential (its OIDC token, or on a pull request from a fork its
    `GITHUB_TOKEN`) for a short-lived first-party token. That token is accepted
    only by `PUT /v2/impacted-targets`, by `GET
    /v2/pull-requests/{id}/impacted-targets` and, on a fork pull request, by the
    Flaky Tests CLI endpoints. It works only for the run's own repository. On a
    fork pull request it works only for that pull request, and the upload works
    only for the pull request's head sha.


    ## Errors


    Errors from the API are an `ErrorResponse`: `{ "error": { "code", "message"
    } }`. Switch on `code`, which is stable; `message` is prose and may change
    at any time.


    Some responses don't have this shape. Trunk's edge answers `401`, `403` for
    some credential problems (including a request with no credential), `429`,
    and gateway errors such as `503` before the request reaches the API. The API
    itself answers `413` for a body over 512 KB and `504` for a request that
    runs past its time limit (usually 5 seconds), both as plain text. Read
    `error.code` only when the body is JSON with an `error` object, and
    otherwise branch on the status code.


    **An authorization denial on a read is reported as `404`, not `403`** —
    whether a resource exists must not leak across organizations, so a resource
    in another organization is indistinguishable from one that does not exist.
    `403 INSUFFICIENT_PERMISSIONS` means the credential is valid but is not
    permitted the action (or carries no organization).


    Every response from the API carries an `X-Request-Id` header; edge responses
    may not. Quote it in support requests.


    ## Rate limiting


    Most requests share one limit per organization (currently 100 requests per
    second), across every API key, user, and CLI session in it. Some requests
    have limits of their own and don't count toward it: `GET` requests on paths
    that start with `/v2/pull-requests`, `/v2/ci-jobs`, `/v2/ci-workflow-runs`,
    or `/v2/ci-failure-clusters` (5 per second per API key or user); the merge
    queue metrics endpoints (5 per second per organization); every request from
    a GitHub Actions login, which includes impacted-target uploads and reads and
    the Flaky Tests CLI endpoints on a fork pull request (10 per second per
    repository, and separately for its fork pull requests; the other limits in
    this list do not apply to it); test-result uploads (1000 per second per
    organization) and quarantine lookups (250 per second per organization).
    Exceeding a limit returns `429`; retry with backoff. The limit is enforced
    at the edge, which does not yet wrap its `429` in the `ErrorResponse`
    envelope or send `Retry-After`, so treat any `429` as rate limiting
    regardless of body.


    ## Compatibility


    Within v2, Trunk may add: new endpoints, new **optional** response fields,
    new members to any enum (including new `code` values, new queue-entry
    states, and new providers), and new optional request parameters. **Clients
    must tolerate values and fields they do not recognize** rather than failing
    closed — a client that switches exhaustively over an enum will break when a
    member is added. Removals and semantic changes require a new major version.


    ## Provider support


    Merge queues, verification runs and checks are **GitHub-only** today;
    `Check.provider` has a single member for that reason. `PUT
    /v2/impacted-targets` accepts GitHub and GitLab repositories. A GitHub
    Actions login (the `trunk-io/login` action, or `trunk auth login
    --github-actions`) uploads only for its own GitHub repository. The
    `Provider` enum lists values the repository index can store, not surfaces
    that are fully supported.


    ## Not yet available


    A pull request's numeric **position** in its queue is not exposed, and list
    responses are not ordered by queue position. `GET
    /v2/merge-queues/{id}/order` returns the order the engine will consider pull
    requests in, but an array index there is not a wait: use a pending entry's
    `directlyAhead` rather than counting, and `GET
    /v2/pull-requests/{id}/queue-entry-estimate` for when it is expected to
    merge (on queues that serve estimates). This API delivers no events of its
    own — poll it, or subscribe to [Merge Queue's
    webhooks](https://docs.trunk.io/merge-queue/webhooks). `Idempotency-Key` is
    not yet honored, so a mutation that times out must be reconciled by reading
    the resource back rather than blindly retried.
  contact:
    name: Trunk Support
    url: https://docs.trunk.io
servers:
  - url: https://api.trunk.io
    description: Production
security:
  - apiKey: []
  - trunkToken: []
tags:
  - name: mergeQueues
    x-group: Merge Queues
  - name: pullRequests
    x-group: Pull Requests
  - name: mergeQueueVerificationRuns
    x-group: Verification Runs
  - name: impactedTargets
    x-group: Impacted Targets
  - name: repositories
    x-group: Repositories
  - name: dynamicCi
    x-group: Dynamic CI
  - name: ciJobs
    x-group: CI Jobs
  - name: ciWorkflowRuns
    x-group: CI Workflow Runs
  - name: ciFailureClusters
    x-group: CI Failure Clusters
  - name: testCollections
    x-group: Test Collections
  - name: tests
    x-group: Tests
  - name: testUploads
    x-group: Test Uploads
  - name: detectionEvents
    x-group: Detection Events
  - name: monitors
    x-group: Monitors
  - name: monitorTests
    x-group: Monitor Tests
paths:
  /v2/merge-queue-verification-runs/{id}:
    get:
      tags:
        - mergeQueueVerificationRuns
      summary: Get a verification run
      description: >-
        Returns one merge-queue verification run, including its normalized CI
        checks, the pull requests it tested, and the impacted targets uploaded
        for its commits.
      operationId: mergeQueueVerificationRuns.get
      parameters:
        - schema:
            type: string
            description: The verification run's id.
            example: a1b2c3d4-e5f6-4718-9a0b-1c2d3e4f5061
          required: true
          description: The verification run's id.
          name: id
          in: path
      responses:
        '200':
          description: The verification run
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/VerificationRun'
        '401':
          description: >-
            `AUTHENTICATION_REQUIRED` | `INVALID_TOKEN`. A malformed, expired,
            or deleted credential. Trunk's edge usually answers this before the
            request reaches the API, with a body that is not this envelope
            (`{"error": "unauthorized: invalid api key"}` for a bad API key, or
            plain text for a bad `x-trunk-token`), so branch on the status. A
            request with no credential at all gets `403` from the edge.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              examples:
                AUTHENTICATION_REQUIRED:
                  summary: AUTHENTICATION_REQUIRED
                  value:
                    error:
                      code: AUTHENTICATION_REQUIRED
                      message: No credential was supplied
                INVALID_TOKEN:
                  summary: INVALID_TOKEN
                  value:
                    error:
                      code: INVALID_TOKEN
                      message: The supplied token failed verification
        '404':
          description: '`VERIFICATION_RUN_NOT_FOUND`'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              examples:
                VERIFICATION_RUN_NOT_FOUND:
                  summary: VERIFICATION_RUN_NOT_FOUND
                  value:
                    error:
                      code: VERIFICATION_RUN_NOT_FOUND
                      message: Verification run not found
        '429':
          description: >-
            `RATE_LIMIT_EXCEEDED`. Trunk's edge answers this, and does not yet
            wrap it in the error envelope or send `Retry-After`: treat any `429`
            as rate limiting, whatever its body, and retry with backoff.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              examples:
                RATE_LIMIT_EXCEEDED:
                  summary: RATE_LIMIT_EXCEEDED
                  value:
                    error:
                      code: RATE_LIMIT_EXCEEDED
                      message: Rate limit exceeded; retry with backoff
        '500':
          description: '`INTERNAL_ERROR`'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              examples:
                INTERNAL_ERROR:
                  summary: INTERNAL_ERROR
                  value:
                    error:
                      code: INTERNAL_ERROR
                      message: An unexpected error occurred
components:
  schemas:
    VerificationRun:
      type: object
      properties:
        id:
          type: string
          example: a1b2c3d4-e5f6-4718-9a0b-1c2d3e4f5061
        isBisection:
          type: boolean
          description: >-
            True when this run exists to attribute a failed batch to a specific
            entry, rather than to verify new work.
          example: false
        testBranch:
          type: string
          description: The ephemeral branch the queue built to run this verification on.
          example: trunk-merge/01HX3K
        testBranchSha:
          type: string
          example: 1f0a9b8c7d6e5f40312233445566778899aabbcc
        testBranchCommitUrl:
          type: string
          description: >-
            The tested commit on the provider, for a human to open — v1
            publishes this same link as `testBranchUrl`, which addresses the
            commit rather than the branch. Built for GitHub (`/commit/`) and
            GitLab (`/-/commit/`) repositories. Absent on any other forge, and
            for a run that never got a tested commit (one cancelled before it
            started).
          example: >-
            https://github.com/acme/widgets/commit/1f0a9b8c7d6e5f40312233445566778899aabbcc
        createdAt:
          type: string
          format: date-time
          description: When the run was created.
          example: '2026-07-28T11:05:00.000Z'
        updatedAt:
          type: string
          format: date-time
          description: >-
            When the run last changed. For a finished run this approximates when
            it concluded; there is no separate `finishedAt` yet.
          example: '2026-07-28T11:35:00.000Z'
        status:
          $ref: '#/components/schemas/VerificationRunStatus'
        requiredStatusesSource:
          $ref: '#/components/schemas/RequiredStatusesSource'
        requiredStatuses:
          type: array
          items:
            type: string
          maxItems: 10000
          description: >-
            Names of the checks that were required for this run, snapshotted
            when it started (resolved from the queue's configured statuses, then
            `.trunk/trunk.yaml`, then the branch's GitHub protection contexts).
            A check in `checks` is required iff its `name` is in this list; the
            checks themselves carry no required flag. Empty means nothing was
            required.
          example:
            - Lint (typescript)
            - Test (rust)
        checks:
          type: array
          items:
            $ref: '#/components/schemas/Check'
          maxItems: 10000
          description: >-
            Every check the run observed, provider check runs and commit
            statuses normalized to one shape. A failure here is the usual reason
            an entry left `testing` for `failed`.
        testedPullRequests:
          type: array
          items:
            $ref: '#/components/schemas/TestedPullRequest'
          maxItems: 10000
          description: >-
            The pull requests included in this run. More than one means the
            entries were batched, so a failure is attributable to any of them
            until bisection narrows it.
        dependentPullRequests:
          type: array
          items:
            $ref: '#/components/schemas/DependentPullRequest'
          maxItems: 10000
          description: >-
            Pull requests whose commits were merged into the test branch to
            build the predicted base, but which this run is not testing. A
            merged-in commit is absent here when it belongs to no pull request
            (a plain base-branch commit) or when that pull request's branch has
            moved since the run, so this list is usually shorter than what the
            run carried. It can also be longer: a commit is matched by
            (repository, sha), which is indexed but not unique, so one merged-in
            commit resolves to every pull request in the repository whose head
            is that sha.
        testBranchPullRequest:
          $ref: '#/components/schemas/TestBranchPullRequest'
        impactedTargets:
          $ref: '#/components/schemas/VerificationRunImpactedTargets'
      required:
        - id
        - isBisection
        - testBranch
        - testBranchSha
        - createdAt
        - updatedAt
        - status
        - requiredStatuses
        - checks
        - testedPullRequests
        - dependentPullRequests
    ErrorResponse:
      type: object
      properties:
        error:
          type: object
          properties:
            code:
              $ref: '#/components/schemas/ErrorCode'
            message:
              type: string
              description: >-
                Human-readable description of what went wrong. Not stable — do
                not parse.
              example: An unexpected error occurred
          required:
            - code
            - message
      required:
        - error
      description: >-
        The error envelope. Every error this API itself returns has this shape,
        except a `413` for a body over 512 KB and a `504` for a request that
        runs past its time limit, which are plain text. Responses from Trunk's
        edge, such as a `401`, a `403` for a missing credential, a `429` or a
        `503`, can arrive before the request reaches the API and may not have
        it, so read `error.code` only when the body is JSON with an `error`
        object.
    VerificationRunStatus:
      type: string
      enum:
        - inProgress
        - failed
        - cancelled
        - succeeded
      description: >-
        `inProgress` — checks are still running. `succeeded` — every required
        check passed. `failed` — a required check failed, or the run exceeded
        the queue's `testingTimeoutMinutes` (the two are not distinguished
        today). `cancelled` — the engine abandoned the run, typically because
        the entry left the queue or an entry ahead of it failed.
      example: succeeded
    RequiredStatusesSource:
      type: string
      enum:
        - trunkConfig
        - repoProviderBranchProtection
        - mergeInstance
      description: >-
        Where the queue resolved a run's required checks from, in the order it
        tries them: `mergeInstance` — the queue's own configured list;
        `trunkConfig` — `merge.required_statuses` in the repository's
        `.trunk/trunk.yaml`, read off the test branch;
        `repoProviderBranchProtection` — the target branch's protection rules at
        the provider. Absent in two cases: a run recorded before Trunk stored
        the source (before 2024-01-24), and a run cancelled before it started,
        which resolved no statuses at all and carries an empty
        `requiredStatuses` with it. v1 reports both as `trunk_config`, which is
        its merge service's default rather than an observation.
      example: trunkConfig
    Check:
      type: object
      properties:
        id:
          type: string
          example: '31245987'
        name:
          type: string
          example: build
        kind:
          $ref: '#/components/schemas/CheckKind'
        status:
          $ref: '#/components/schemas/CheckStatus'
        conclusion:
          $ref: '#/components/schemas/CheckConclusion'
        providerStatus:
          $ref: '#/components/schemas/ProviderCheckStatus'
        providerConclusion:
          $ref: '#/components/schemas/ProviderCheckConclusion'
        countsAsPass:
          type: boolean
          description: >-
            GitLab only: whether GitLab counts the check as passing. A failed
            job or commit status with `allow_failure` counts as passing, so
            `conclusion` is `failure` and this is `true`. Absent on GitHub.
          example: true
        url:
          type:
            - string
            - 'null'
          description: >-
            Link to the check at its provider, for a human to open. Null when
            the provider did not supply one.
          example: https://github.com/acme/widgets/runs/31245987
        provider:
          $ref: '#/components/schemas/ForgeProvider'
      required:
        - id
        - name
        - kind
        - status
        - conclusion
        - url
        - provider
      description: >-
        A normalized CI check. GitHub check runs, GitLab jobs and commit
        statuses map onto this one shape; `kind` says which one this is. On
        GitHub the `provider*` fields carry the unfolded values; on GitLab
        `countsAsPass` carries GitLab's own verdict, and only the job or status
        that ran last for each pipeline and name is listed.
    TestedPullRequest:
      type: object
      properties:
        id:
          type: string
          description: >-
            The pull request's id in this API — pass it to `GET
            /v2/pull-requests/{id}`.
          example: 6f1d2c3b-4a59-4e6f-8a7b-9c0d1e2f3a4b
        number:
          type: integer
          example: 4901
        sha:
          type: string
          description: >-
            The head commit that was included in this run. Compare with the pull
            request's current `sha` to detect that its branch moved since.
          example: 9c58bf40e5c1a2b3d4e5f60718293a4b5c6d7e8f
        title:
          type: string
          example: Add the widget endpoint
        url:
          type: string
          description: >-
            The pull request on its provider. Absent until Trunk's sync has
            populated it.
          example: https://github.com/acme/widgets/pull/4901
      required:
        - id
        - number
        - sha
        - title
      description: >-
        A pull request included in a verification run. When a run covers
        several, a failure is attributable to any of them — that is what
        bisection resolves.
    DependentPullRequest:
      type: object
      properties:
        id:
          type: string
          description: >-
            The pull request's id in this API — pass it to `GET
            /v2/pull-requests/{id}`.
          example: 6f1d2c3b-4a59-4e6f-8a7b-9c0d1e2f3a4b
        number:
          type: integer
          example: 4901
        sha:
          type: string
          description: >-
            The commit of this pull request that was merged into the test
            branch. It equals the pull request's stored head by construction —
            the lookup matches on it — so a pull request whose branch moved
            after the run is absent from this list rather than listed with an
            old sha.
          example: 0a1b2c3d4e5f60718293a4b5c6d7e8f90a1b2c3d
        title:
          type: string
          example: Add the widget endpoint
        url:
          type: string
          description: >-
            The pull request on its provider. Absent until Trunk's sync has
            populated it.
          example: https://github.com/acme/widgets/pull/4901
      required:
        - id
        - number
        - sha
        - title
      description: >-
        A pull request whose commit was merged into the test branch to form the
        predicted base, but which this run is not testing. Same shape as
        `TestedPullRequest`; the distinction is whether a failure is
        attributable to it.
    TestBranchPullRequest:
      type: object
      properties:
        number:
          type: integer
          example: 5002
        url:
          type: string
          example: https://github.com/acme/widgets/pull/5002
      required:
        - number
        - url
      description: >-
        The pull request or merge request the queue opened for the test branch,
        where its checks and logs are. On GitHub, the pull request the queue
        opened for the test branch, present only when the queue is configured to
        open one. On GitLab, the draft merge request the queue always opens for
        the test branch; `number` is its iid and `url` its web URL, e.g.
        `https://gitlab.com/acme/widgets/-/merge_requests/42`.
    VerificationRunImpactedTargets:
      type: object
      properties:
        all:
          $ref: '#/components/schemas/ImpactedTargetSet'
        testedPullRequestsOnly:
          $ref: '#/components/schemas/ImpactedTargetSet'
      required:
        - all
      description: >-
        The impacted targets uploaded for the run's commits (`PUT
        /impacted-targets`). Returned only when a single run is fetched by ID,
        never in a list, and absent when no commit on the run has an upload.
        `all` spans every commit the run carried: the pull requests under test
        and the commits merged in beneath them to build the predicted base.
        `testedPullRequestsOnly` spans the tested pull requests' commits alone,
        and is absent when none of them uploaded. A commit with no upload
        contributes nothing to either set.
    ErrorCode:
      type: string
      enum:
        - AUTHENTICATION_REQUIRED
        - INVALID_TOKEN
        - INSUFFICIENT_PERMISSIONS
        - INTERNAL_ERROR
        - VALIDATION_FAILED
        - NOT_FOUND
        - INVALID_CURSOR
        - MERGE_QUEUE_NOT_FOUND
        - PR_ALREADY_ENQUEUED
        - PR_NOT_ENQUEUEABLE
        - UPSTREAM_ERROR
        - VERIFICATION_RUN_NOT_FOUND
        - PR_NOT_FOUND
        - IMPACTED_TARGETS_NOT_FOUND
        - REPOSITORY_NOT_FOUND
        - IMPACTED_TARGETS_UNSUPPORTED
        - QUEUE_ALREADY_EXISTS
        - QUEUE_HAS_ACTIVE_ENTRIES
        - MODE_CHANGE_IN_PROGRESS
        - PR_NOT_IN_ACTIVE_STATE
        - MERGE_QUEUE_NOT_CREATABLE
        - PR_TESTS_NOT_RESTARTABLE
        - ALLOWED_BOT_SUBMITTERS_FROZEN
        - ESTIMATE_NOT_ENABLED
        - PR_RERUN_FEATURE_DISABLED
        - PR_RERUN_NOT_PENDING_FAILURE
        - PR_RERUN_QUEUE_DOES_NOT_KEEP_FAILED_RUNS
        - PR_RERUN_NOT_A_REQUIRED_CHECK_FAILURE
        - PR_RERUN_CHECK_NOT_RERUNNABLE
        - PR_RERUN_RUN_TORN_DOWN
        - PR_RERUN_HOLD_LIMIT_REACHED
        - PR_RERUN_FORGE_NOT_SUPPORTED
        - MERGE_QUEUE_FORGE_NOT_SUPPORTED
        - PROVIDER_URL_NOT_FOUND
        - CI_HOST_UNSUPPORTED
        - CI_JOB_NOT_FOUND
        - CI_FAILURE_CLUSTER_NOT_FOUND
        - TEST_COLLECTION_NOT_FOUND
        - TEST_NOT_FOUND
        - TEST_UPLOAD_NOT_FOUND
        - MONITOR_NOT_FOUND
        - MONITOR_LIMIT_EXCEEDED
        - MONITOR_NOT_ACTIVE
        - OUT_OF_RANGE
        - TEST_UNAVAILABLE
        - TICKETING_NOT_CONFIGURED
        - TICKETING_CREDENTIALS_INVALID
        - TICKETING_SITE_REFUSED
        - TICKET_NOT_FOUND
        - TICKET_NOT_LINKED
        - TICKET_LINK_CONFLICT
        - TEST_ALREADY_LINKED
        - TICKET_FIELDS_REJECTED
        - TICKET_CONTENT_UNAVAILABLE
        - TICKETING_CREATE_REFUSED
        - RATE_LIMIT_EXCEEDED
      description: >-
        Stable machine-readable error identifier. Switch on this, never on
        `message`. A shipped code's meaning never changes, but **new codes may
        be added within v2** — treat an unrecognized code as a generic failure
        of its HTTP status rather than failing closed.
      example: INTERNAL_ERROR
    CheckKind:
      type: string
      enum:
        - checkRun
        - statusCheck
        - job
      description: >-
        Which provider entity a check is. `checkRun` is a GitHub check run, with
        its own lifecycle; `job` is a GitLab CI job; `statusCheck` is a commit
        status on either forge. On GitHub it decides how to read
        `providerConclusion`.
      example: checkRun
    CheckStatus:
      type: string
      enum:
        - queued
        - inProgress
        - completed
      description: >-
        A check's lifecycle. Only `completed` means `conclusion` is final; for
        `queued` and `inProgress` the conclusion is a placeholder (`neutral`).
      example: completed
    CheckConclusion:
      type: string
      enum:
        - success
        - failure
        - neutral
        - cancelled
        - skipped
        - timeout
      description: >-
        A check's outcome. `neutral` is also the placeholder for a check that
        has not concluded yet.
      example: success
    ProviderCheckStatus:
      type: string
      enum:
        - QUEUED
        - IN_PROGRESS
        - COMPLETED
        - PENDING
        - WAITING
        - REQUESTED
      description: >-
        A check's status as the provider reported it, before normalization,
        uppercased as Trunk stores it — the vocabulary v1 publishes. `WAITING`
        and `PENDING` are the deployment-gate states: a check run in one of them
        is waiting on a manual approval, not running, and the normalized
        `status` reports `QUEUED`, `REQUESTED`, `WAITING` and `PENDING` alike as
        `queued`. Absent on a `statusCheck`, which has no lifecycle of its own,
        on a check run whose provider set none, and on GitLab.
      example: COMPLETED
    ProviderCheckConclusion:
      type: string
      enum:
        - ACTION_REQUIRED
        - CANCELLED
        - ERROR
        - FAILURE
        - NEUTRAL
        - PENDING
        - SKIPPED
        - STALE
        - SUCCESS
        - TIMED_OUT
      description: >-
        The provider's own verdict, before normalization, uppercased as Trunk
        stores it. Read it with `kind`: a `checkRun` uses GitHub's check-run
        conclusions (everything here but `ERROR`), a `statusCheck` its
        commit-status states (`SUCCESS`, `FAILURE`, `ERROR`, `PENDING`). This is
        where the values the normalized `conclusion` cannot express survive — it
        folds `ACTION_REQUIRED` and `STALE` to `neutral`, and `ERROR` to
        `failure` beside a genuine `FAILURE`. Absent when the provider set none,
        and on GitLab.
      example: SUCCESS
    ForgeProvider:
      type: string
      enum:
        - github
        - gitlab
      description: >-
        The forge a value comes from. More forges may be added; treat an unknown
        value as a forge this client does not handle.
      example: github
    ImpactedTargetSet:
      type: object
      properties:
        impactsAllTargets:
          type: boolean
          description: >-
            True when any commit in this set uploaded `impactsAllTargets: true`,
            which makes the explicit lists of the others moot.
          example: false
        impactedTargets:
          type: array
          items:
            type: string
          maxItems: 100000
          description: >-
            The union of the commits' uploaded targets, sorted and deduplicated.
            Empty when `impactsAllTargets` is true, and also when every upload
            was an explicit empty list — the commits impact nothing. Truncated
            to the first 100,000 targets; `totalImpactedTargets` says whether it
            was.
          example:
            - //lib/db
            - //svc/api
        totalImpactedTargets:
          type: integer
          description: >-
            The size of the union before truncation. 0 when `impactsAllTargets`
            is true.
          example: 2
      required:
        - impactsAllTargets
        - impactedTargets
        - totalImpactedTargets
      description: The impacted targets of a set of commits on a verification run.
  securitySchemes:
    apiKey:
      type: http
      scheme: bearer
      description: >-
        An API key, sent as `Authorization: Bearer <key>`. An organization admin
        creates one in the Trunk app under **Settings → Developer → API Keys**
        and chooses the permissions it holds. A new key starts with no
        permissions: it can read merge queues but change nothing in them, and it
        cannot get a Dynamic CI plan. Each endpoint that needs a permission
        names it in its description; the Dynamic CI plan endpoints need
        **Generate Dynamic CI plans**.
    trunkToken:
      type: apiKey
      in: header
      name: x-trunk-token
      description: >-
        A short-lived token that Trunk's own tools send in the `x-trunk-token`
        header: the `trunk` CLI after `trunk auth login`, and the
        `trunk-io/login` action in a GitHub Actions run. Your own integrations
        should use an API key instead. Never send `Authorization` and
        `x-trunk-token` on the same request.


        **A token from a GitHub Actions run can only upload and read impacted
        targets** (`PUT /v2/impacted-targets` and `GET
        /v2/pull-requests/{id}/impacted-targets`), for the repository the run
        belongs to. On a pull request from a fork it can also call the Flaky
        Tests CLI endpoints. Every other endpoint refuses it.

````