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

# Withdraw a team version

> Withdraws one published version: it is no longer "latest", is left out of lists and can't
be installed by name, but stays readable by id, so runs and installed teams that use it keep
working. Its files are kept and its number can't be published again. The team and its other
versions stay.

Requires a token whose user can see the team given by `team_id` or `name`: a public listed team, or a team of an organization you belong to.



## OpenAPI

````yaml /openapi/hub-by-tag/hub-teams.yaml post /v1/teams/delete_version
openapi: 3.0.3
info:
  title: 'CliqHub API: Teams'
  version: 1.0.0
  description: >-
    The CliqHub team registry. A team is published under a scope
    (`@acme/code-review`) as

    numbered versions. Create a draft, change it (each change can mint the next
    version),

    publish it to make it installable, then install it on daemons. List teams
    with a

    `realm_id` to see a realm's roster and where each team is installed, or with
    a

    `daemon_id` to see what one daemon has. Build a team with AI drafts a team
    from a

    description.


    Changing a team (update, publish, withdraw a version, unpublish, delete)
    needs its author, or the

    publish permission in the organization that owns its scope.
servers:
  - url: https://{host}
    variables:
      host:
        default: cliqhub.io
        description: CliqHub host
security: []
tags:
  - name: Teams
    description: >-
      The CliqHub team registry. A team is published under a scope
      (`@acme/code-review`) as

      numbered versions. Create a draft, change it (each change can mint the
      next version),

      publish it to make it installable, then install it on daemons. List teams
      with a

      `realm_id` to see a realm's roster and where each team is installed, or
      with a

      `daemon_id` to see what one daemon has. Build a team with AI drafts a team
      from a

      description.


      Changing a team (update, publish, withdraw a version, unpublish, delete)
      needs its author, or the

      publish permission in the organization that owns its scope.
paths:
  /v1/teams/delete_version:
    post:
      tags:
        - Teams
      summary: Withdraw a team version
      description: >-
        Withdraws one published version: it is no longer "latest", is left out
        of lists and can't

        be installed by name, but stays readable by id, so runs and installed
        teams that use it keep

        working. Its files are kept and its number can't be published again. The
        team and its other

        versions stay.


        Requires a token whose user can see the team given by `team_id` or
        `name`: a public listed team, or a team of an organization you belong
        to.
      operationId: POST_v1_teams_delete_version
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              properties:
                name:
                  type: string
                  minLength: 1
                  description: Team name
                scope:
                  type: string
                  description: Scope (publisher) slug
                version:
                  type: string
                  minLength: 1
                  description: The version to withdraw
              required:
                - name
                - version
            examples:
              default:
                value:
                  scope: acme
                  name: code-review
                  version: 1.4.0
      responses:
        '200':
          description: Success.
          content:
            application/json:
              schema:
                type: object
                required:
                  - ok
                  - data
                properties:
                  ok:
                    type: boolean
                    enum:
                      - true
                    description: Always `true` on success.
                  data:
                    type: object
                    required:
                      - withdrawn
                      - version
                    properties:
                      withdrawn:
                        type: boolean
                        enum:
                          - true
                      version:
                        type: string
              example:
                ok: true
                data:
                  withdrawn: true
                  version: 1.4.0
        '401':
          description: >-
            `unauthorized`: No `Authorization` header, or the token is
            malformed, expired or revoked.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HubErr'
              examples:
                unauthorized:
                  summary: unauthorized
                  value:
                    ok: false
                    error:
                      code: unauthorized
                      message: Authentication required
        '403':
          description: >-
            `forbidden`: You can see the record but your role in its realm is
            too low or lacks the required permission.


            `forbidden`: You lack the delete permission in the scope's
            organization.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HubErr'
              examples:
                forbidden:
                  summary: forbidden
                  value:
                    ok: false
                    error:
                      code: forbidden
                      message: You do not have access to do this
                forbidden (endpoint):
                  summary: forbidden (endpoint)
                  value:
                    ok: false
                    error: >-
                      Publishing to @acme needs 'teams.publish.delete' in its
                      org
                    code: forbidden
        '404':
          description: >-
            `not_found`: The team does not exist or is in a realm you cannot see
            (404 rather than 403, so its existence is not revealed).


            `not_found`: No such team or version.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HubErr'
              examples:
                not_found:
                  summary: not_found
                  value:
                    ok: false
                    error:
                      code: not_found
                      message: Not found
                not_found (endpoint):
                  summary: not_found (endpoint)
                  value:
                    ok: false
                    error: Version 1.4.0 not found
                    code: not_found
        '409':
          description: '`conflict`: The version is already withdrawn.'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HubErr'
              examples:
                conflict:
                  summary: conflict
                  value:
                    ok: false
                    error: Version 1.4.0 is already withdrawn
                    code: conflict
        '422':
          description: >-
            `invalid_params`: The body fails the request schema: a required
            field is missing or a value has the wrong type or format. The
            message lists every issue as `field: problem`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HubErr'
              examples:
                invalid_params:
                  summary: invalid_params
                  value:
                    ok: false
                    error: 'name: Required'
                    code: invalid_params
        '500':
          description: >-
            `internal_error`: An unexpected server fault. Retry later; if it
            persists, report it with the time of the request.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HubErr'
              examples:
                internal_error:
                  summary: internal_error
                  value:
                    ok: false
                    error: Internal server error
                    code: internal_error
      security:
        - BearerAuth: []
components:
  schemas:
    HubErr:
      type: object
      required:
        - ok
        - error
      description: >-
        Every failure. Route-policy denials (401/403/404, and 400 when neither
        realm_id nor org_id was sent) answer `error` as `{ code, message }`;
        errors raised by the endpoint answer `error` as the message with the
        code beside it in `code`. Every error has a code. See
        [Errors](/hub-api/errors).
      properties:
        ok:
          type: boolean
          description: Always false on error
        error:
          description: The message, or `{ code, message }` for an access denial.
          oneOf:
            - type: string
            - type: object
              required:
                - code
                - message
              properties:
                code:
                  type: string
                message:
                  type: string
        code:
          type: string
          description: Stable error code of an endpoint error.
        details:
          type: object
          additionalProperties: true
          description: Structured detail, when there is some.
  securitySchemes:
    BearerAuth:
      type: http
      scheme: bearer
      bearerFormat: cliq_tok_* | cliq_dt_*
      description: >-
        User PAT (`cliq_tok_…`, including session-scoped) or realm token
        (`cliq_dt_…`).

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.