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

# Delete a Template

> Soft-deletes the Template so it disappears from tenant-visible lists.
Existing Sandboxes are not affected because their effective Template
configuration is copied at creation time.

GMI attempts to reclaim provider Build artifacts before completing the
logical delete. When the selected IDC cannot reclaim an artifact, the
Build remains with `artifact_state=retained` after soft-delete. When
reclaim is blocked by a dependent resource, the request fails with
`Template.HasDependents` (409) and nothing is soft-deleted.

Deletion is also rejected while a Build is in progress, and when
GMI-tracked dependents still reference the Template's Builds (for
example child Templates, Snapshots, or live Sandboxes).




## OpenAPI

````yaml /api-spec/sandbox_api.yaml delete /templates/{id}
openapi: 3.0.3
info:
  title: GMI Sandbox API
  description: >-
    REST API for GMI Sandbox: create isolated execution environments from
    templates, manage their lifecycle on the control plane, and run commands or
    transfer files through each sandbox's own data plane.
  contact:
    name: GMI Cloud Support
    email: support@gmicloud.ai
  version: '2.0'
servers:
  - url: https://console.gmicloud.ai/api/v2
    description: Control plane
security:
  - bearerAuth: []
tags:
  - name: Sandbox
    description: |
      Sandbox instance lifecycle management (Sandbox v2, /api/v2/sandboxes)
  - name: SandboxTemplate
    description: Sandbox template management (Sandbox v2, `/api/v2/templates`)
  - name: Sandbox-Exec
    description: >
      Sandbox execution data plane (accessed via the sandbox host and sandbox
      access token). These endpoints are not under the control plane's `/api/v2`
      path; clients connect directly to `https://{sandbox_key}.{domain}` and
      authenticate with `X-Access-Token`.
  - name: Sandbox-Files
    description: >
      Sandbox file data plane (`/files`). **These endpoints are not under
      `/api/v2`** and do not use `Authorization: Bearer`: they are served by the
      sandbox's own data-plane entry point — clients connect directly to
      `https://{sandbox_key}.{domain}` and authenticate with `X-Access-Token`.
      `{sandbox_key}` is the `sandbox_key` returned by the create/connect
      endpoints, used for data-plane host addressing. `{domain}` and
      `X-Access-Token` are the `domain` and `sandbox_access_token` from the same
      responses — no extra endpoint is needed to obtain them.


      This split is not historical baggage but the nature of a data plane: file
      transfer is long-lived, high-volume, and addressed per sandbox, differing
      from the control plane's short requests in both capacity model and failure
      domain, so they do not share an entry point.


      **One unified abstraction.** The same contract is served by two backend
      kinds (an in-sandbox file service / a data-center data-plane proxy);
      clients need not — and cannot — tell them apart. The cost is that the
      contract is their intersection: `Content-Length` on download and resumable
      download (`Range`/`206`) are **optional capabilities** that vary by data
      center, and clients must work correctly when they are absent. See the
      per-operation notes below.
paths:
  /templates/{id}:
    parameters:
      - $ref: '#/components/parameters/TemplateIdPathParam'
      - $ref: '#/components/parameters/IdcNameQueryParam'
    delete:
      tags:
        - SandboxTemplate
      summary: Delete a Template
      description: |
        Soft-deletes the Template so it disappears from tenant-visible lists.
        Existing Sandboxes are not affected because their effective Template
        configuration is copied at creation time.

        GMI attempts to reclaim provider Build artifacts before completing the
        logical delete. When the selected IDC cannot reclaim an artifact, the
        Build remains with `artifact_state=retained` after soft-delete. When
        reclaim is blocked by a dependent resource, the request fails with
        `Template.HasDependents` (409) and nothing is soft-deleted.

        Deletion is also rejected while a Build is in progress, and when
        GMI-tracked dependents still reference the Template's Builds (for
        example child Templates, Snapshots, or live Sandboxes).
      operationId: deleteTemplate
      responses:
        '200':
          description: |
            Deletion completed synchronously: the Template is soft-deleted and
            the provider artifact reclaim attempt has already settled. There is
            nothing left to poll.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/TemplateDeletionAccepted'
        '400':
          $ref: '#/components/responses/BadRequest'
        '401':
          $ref: '#/components/responses/Unauthorized'
        '403':
          $ref: '#/components/responses/Forbidden'
        '404':
          $ref: '#/components/responses/NotFound'
        '409':
          $ref: '#/components/responses/Conflict'
        '500':
          $ref: '#/components/responses/InternalError'
components:
  parameters:
    TemplateIdPathParam:
      name: id
      in: path
      required: true
      description: GMI Template identifier.
      schema:
        type: string
        format: uuid
    IdcNameQueryParam:
      name: idc_name
      in: query
      description: Filter by data center name, e.g. us-denver-1
      schema:
        type: string
  schemas:
    TemplateDeletionAccepted:
      type: object
      additionalProperties: false
      required:
        - request_id
        - data
      properties:
        request_id:
          type: string
          description: Deletion request correlation identifier.
        data:
          type: object
          additionalProperties: false
          required:
            - id
            - deleted
          properties:
            id:
              type: string
              description: Logically deleted GMI Template identifier.
            deleted:
              type: boolean
              enum:
                - true
              description: Confirms that logical deletion is complete.
    ErrorResponse:
      type: object
      required:
        - code
        - message
        - request_id
      properties:
        code:
          type: string
          description: Machine-readable business error code
          example: Resource.QuotaExceeded
        message:
          type: string
          description: Human-readable error description
          example: The resource quota is not enough.
        request_id:
          type: string
          description: Tracing ID
          example: req-xxxx
        details:
          type: object
          description: Field-level error details
          additionalProperties: true
  responses:
    BadRequest:
      description: Invalid request parameters
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorResponse'
          example:
            code: Parameter.Invalid
            message: Invalid request parameters
            request_id: req-xxxx
    Unauthorized:
      description: Unauthenticated
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorResponse'
          example:
            code: Auth.Unauthorized
            message: Authentication required
            request_id: req-xxxx
    Forbidden:
      description: The caller cannot access the organization-scoped resource.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorResponse'
    NotFound:
      description: Resource not found
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorResponse'
          example:
            code: Resource.NotFound
            message: The requested resource was not found
            request_id: req-xxxx
    Conflict:
      description: State conflict
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorResponse'
          example:
            code: Resource.StateConflict
            message: Resource state conflict
            request_id: req-xxxx
    InternalError:
      description: Internal server error
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorResponse'
          example:
            code: Internal.ServerError
            message: An internal server error occurred
            request_id: req-xxxx
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      description: >
        API Key or Access Token, always sent as `Authorization: Bearer <token>`.
        The gateway recognizes the token type automatically.

````