# Update a term form

`PATCH https://api.lingohub.com/v2/term-forms/{termFormId}`

LingoHub API V2 (Beta) · [Terms](https://developers.lingohub.com/reference/v2/operations/tags/terms.md) · operation `updateTermForm`

Changes a term form with JSON merge-patch: leaving out a field keeps it, and `null` clears a grammar field or the match expression. The language can't change; add a form in the other language and delete this one. `inherited_by` replaces the list of inheriting languages; a language taken off the list keeps its own copy of the form. A form that other languages inherit must stay preferred. Sending only the current values changes nothing. Send the ETag from getTermForm as If-Match to make sure nobody changed it in between. Requires workspace-level glossaries management permission.

## Parameters

| Parameter | In | Required | Type | Description |
| --- | --- | --- | --- | --- |
| `termFormId` | path | yes | string | Unique identifier of the term form. |
| `If-Match` | header | no | string | Optional precondition. Send the quoted ETag from a GET of this resource. The mutation only runs if a strong tag matches the current representation, checked under the write lock. A comma-separated list is allowed; '*' req… |

## Example request

```sh
curl --request PATCH \
  --url https://api.lingohub.com/v2/term-forms/ter_0197c8f2-5a6b-7cde-8f12-3456789abcde \
  --header 'Authorization: Bearer YOUR_API_KEY' \
  --header 'Content-Type: application/json' \
  --data '{
  "text": "Kasse",
  "inherited_by": [
    "de-AT",
    "de-CH"
  ],
  "form_type": "FULL_FORM",
  "part_of_speech": "NOUN",
  "grammatical_number": "SINGULAR",
  "grammatical_gender": "FEMININE",
  "match_expression": "Kasse[n]?"
}'
```

## Responses

- `200`: The term form.
- `400`: 
- `401`: 
- `403`: 
- `404`: 
- `409`: `already_exists`: the language already has a preferred form (`#/usage_status`).
- `412`: 
- `422`: An inheriting language isn't a supported locale (`enum`) or not a language of the glossary (`not_found`); `AUTOMATIC` matching for a language without it, or a form that others inherit stops being preferred (`not_supporte…
- `429`: 
- `500`: 
- `503`: 

## OpenAPI definition

The complete definition of this operation, with every schema it references:

````json
{
  "openapi": "3.1.0",
  "info": {
    "title": "LingoHub API V2 (Beta)",
    "version": "2.0"
  },
  "servers": [
    {
      "url": "https://api.lingohub.com",
      "description": "LingoHub"
    }
  ],
  "tags": [
    {
      "name": "Terms",
      "description": "Manage the terms of a glossary. Per language, a term has one preferred form and any number of alternatives; a language without forms of its own can inherit another language's preferred form. Untranslatable terms have forms without a language."
    }
  ],
  "paths": {
    "/v2/term-forms/{termFormId}": {
      "patch": {
        "tags": [
          "Terms"
        ],
        "summary": "Update a term form",
        "description": "Changes a term form with JSON merge-patch: leaving out a field keeps it, and `null` clears a grammar field or the match expression. The language can't change; add a form in the other language and delete this one. `inherited_by` replaces the list of inheriting languages; a language taken off the list keeps its own copy of the form. A form that other languages inherit must stay preferred. Sending only the current values changes nothing. Send the ETag from getTermForm as If-Match to make sure nobody changed it in between. Requires workspace-level glossaries management permission.",
        "operationId": "updateTermForm",
        "parameters": [
          {
            "name": "termFormId",
            "in": "path",
            "description": "Unique identifier of the term form.",
            "required": true,
            "schema": {
              "type": "string",
              "description": "Public id that is created from the type prefix of the corresponding resource and its UUID. I.e : For a term language, a valid value would be : ter_0197c8f2-5a6b-7cde-8f12-3456789abcde",
              "pattern": "^ter_[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"
            },
            "example": "ter_0197c8f2-5a6b-7cde-8f12-3456789abcde"
          },
          {
            "name": "If-Match",
            "in": "header",
            "description": "Optional precondition. Send the quoted ETag from a GET of this resource. The mutation only runs if a strong tag matches the current representation, checked under the write lock. A comma-separated list is allowed; '*' requires an existing representation. Weak tags never match. Omit this header for an unconditional write. For an action, use the ETag from GET of the target resource, without the action suffix. A stale tag returns 412; read the current state before retrying.",
            "required": false,
            "schema": {
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/UpdateTermForm"
              }
            },
            "application/merge-patch+json": {
              "schema": {
                "$ref": "#/components/schemas/UpdateTermForm"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "The term form.",
            "headers": {
              "ETag": {
                "$ref": "#/components/headers/ETag"
              },
              "RateLimit": {
                "$ref": "#/components/headers/RateLimit"
              },
              "RateLimit-Policy": {
                "$ref": "#/components/headers/RateLimit-Policy"
              }
            },
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/TermForm"
                }
              }
            }
          },
          "400": {
            "$ref": "#/components/responses/BadRequest"
          },
          "401": {
            "$ref": "#/components/responses/Unauthorized"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          },
          "409": {
            "description": "`already_exists`: the language already has a preferred form (`#/usage_status`).",
            "headers": {
              "RateLimit": {
                "$ref": "#/components/headers/RateLimit"
              },
              "RateLimit-Policy": {
                "$ref": "#/components/headers/RateLimit-Policy"
              }
            },
            "content": {
              "application/problem+json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "412": {
            "$ref": "#/components/responses/PreconditionFailed"
          },
          "422": {
            "description": "An inheriting language isn't a supported locale (`enum`) or not a language of the glossary (`not_found`); `AUTOMATIC` matching for a language without it, or a form that others inherit stops being preferred (`not_supported`).",
            "headers": {
              "RateLimit": {
                "$ref": "#/components/headers/RateLimit"
              },
              "RateLimit-Policy": {
                "$ref": "#/components/headers/RateLimit-Policy"
              }
            },
            "content": {
              "application/problem+json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "429": {
            "$ref": "#/components/responses/TooManyRequests"
          },
          "500": {
            "$ref": "#/components/responses/InternalServerError"
          },
          "503": {
            "$ref": "#/components/responses/ServiceUnavailable"
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    }
  },
  "components": {
    "schemas": {
      "UpdateTermForm": {
        "type": "object",
        "additionalProperties": false,
        "description": "Request body to change a term form with JSON merge-patch: a field left out keeps its value, null clears a nullable field. The language of a form cannot change: add a form in the other language and delete this one instead.",
        "properties": {
          "text": {
            "type": "string",
            "description": "The form's text.",
            "example": "Kasse",
            "maxLength": 4096,
            "minLength": 1
          },
          "usage_status": {
            "$ref": "#/components/schemas/UsageStatus",
            "description": "How the form should be used.",
            "example": "NOT_RECOMMENDED"
          },
          "inherited_by": {
            "type": "array",
            "description": "Languages of the glossary without a form of their own that use this form. Replaces the current list; only for the preferred form of a translatable term. A language removed from the list keeps a copy of the form.",
            "example": [
              "de-AT",
              "de-CH"
            ],
            "items": {
              "type": "string",
              "example": "de-AT",
              "maxLength": 100,
              "minLength": 0
            },
            "maxItems": 100
          },
          "form_type": {
            "description": "Lexical type of the form. Null clears it.",
            "example": "FULL_FORM",
            "oneOf": [
              {
                "$ref": "#/components/schemas/TermFormType"
              },
              {
                "type": "null"
              }
            ]
          },
          "part_of_speech": {
            "description": "Part of speech of the form. Null clears it.",
            "example": "NOUN",
            "oneOf": [
              {
                "$ref": "#/components/schemas/PartOfSpeech"
              },
              {
                "type": "null"
              }
            ]
          },
          "grammatical_number": {
            "description": "Grammatical number of the form. Null clears it.",
            "example": "SINGULAR",
            "oneOf": [
              {
                "$ref": "#/components/schemas/GrammaticalNumber"
              },
              {
                "type": "null"
              }
            ]
          },
          "grammatical_gender": {
            "description": "Grammatical gender of the form. Null clears it.",
            "example": "FEMININE",
            "oneOf": [
              {
                "$ref": "#/components/schemas/GrammaticalGender"
              },
              {
                "type": "null"
              }
            ]
          },
          "matching": {
            "$ref": "#/components/schemas/Matching",
            "description": "How the form is matched against text; `AUTOMATIC` only for languages that support it, also the inheriting ones.",
            "example": "AUTOMATIC"
          },
          "match_expression": {
            "type": [
              "string",
              "null"
            ],
            "description": "The regular expression a `CUSTOM` matching uses. Null clears it.",
            "example": "Kasse[n]?",
            "maxLength": 256
          },
          "case_sensitivity": {
            "$ref": "#/components/schemas/CaseSensitivity",
            "description": "How the form is matched with regard to case.",
            "example": "SENSITIVE"
          }
        }
      },
      "UsageStatus": {
        "type": "string",
        "description": "How a term form should be used:\n  - PREFERRED: the recommended form. A language of a term has at most one preferred form.\n  - ADMITTED: an accepted alternative form.\n  - NOT_RECOMMENDED: a discouraged or deprecated form.\n",
        "enum": [
          "PREFERRED",
          "ADMITTED",
          "NOT_RECOMMENDED"
        ]
      },
      "TermFormType": {
        "type": "string",
        "description": "Lexical type of a term form.",
        "enum": [
          "FULL_FORM",
          "ACRONYM",
          "ABBREVIATION",
          "SHORT_FORM",
          "VARIANT",
          "PHRASE"
        ]
      },
      "PartOfSpeech": {
        "type": "string",
        "description": "Part of speech of the term form.",
        "enum": [
          "NOUN",
          "VERB",
          "ADJECTIVE",
          "ADVERB",
          "PROPER_NOUN",
          "OTHER"
        ]
      },
      "GrammaticalNumber": {
        "type": "string",
        "description": "Grammatical number of the term form.",
        "enum": [
          "SINGULAR",
          "PLURAL",
          "MASS",
          "DUAL",
          "OTHER"
        ]
      },
      "GrammaticalGender": {
        "type": "string",
        "description": "Grammatical gender of the term form.",
        "enum": [
          "MASCULINE",
          "FEMININE",
          "NEUTER",
          "OTHER"
        ]
      },
      "Matching": {
        "type": "string",
        "description": "Strategy used to match the term against translatable text.",
        "enum": [
          "AUTOMATIC",
          "FUZZY",
          "PREFIX",
          "EXACT",
          "CUSTOM"
        ]
      },
      "CaseSensitivity": {
        "type": "string",
        "description": "How a term form is matched with regard to case:\n  - SENSITIVE: only text of the same case matches.\n  - PERMISSIVE: text of any case matches, and a case difference is flagged as a hint.\n  - INSENSITIVE: text of any case matches.\n",
        "enum": [
          "SENSITIVE",
          "PERMISSIVE",
          "INSENSITIVE"
        ]
      },
      "TermForm": {
        "type": "object",
        "description": "One way of writing a term in a language: its preferred form, an admitted alternative, or a form not to use.",
        "properties": {
          "object_type": {
            "type": "string",
            "description": "Always `TERM_FORM`.",
            "enum": [
              "TERM_FORM"
            ],
            "example": "TERM_FORM"
          },
          "id": {
            "type": "string",
            "description": "Unique identifier of the term form.",
            "example": "ter_0197c8f2-5a6b-7cde-8f12-3456789abcde",
            "minLength": 1,
            "pattern": "^ter_[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"
          },
          "term_id": {
            "type": "string",
            "description": "Unique identifier of the term the form belongs to.",
            "example": "te_0197c8f2-5a6b-7cde-8f12-3456789abcde",
            "pattern": "^te_[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"
          },
          "language_code": {
            "type": [
              "string",
              "null"
            ],
            "description": "Language of the form; null for the forms of an untranslatable term.",
            "example": "de"
          },
          "text": {
            "type": "string",
            "description": "The form's text.",
            "example": "Kasse"
          },
          "usage_status": {
            "$ref": "#/components/schemas/UsageStatus",
            "description": "How the form should be used.",
            "example": "PREFERRED"
          },
          "inherited_by": {
            "type": "array",
            "description": "Languages without a form of their own that use this preferred form, e.g. `de-AT` using the `de` form. Empty for every other form.",
            "example": [
              "de-AT",
              "de-CH"
            ],
            "items": {
              "type": "string"
            }
          },
          "form_type": {
            "description": "Lexical type of the form.",
            "example": "FULL_FORM",
            "oneOf": [
              {
                "$ref": "#/components/schemas/TermFormType"
              },
              {
                "type": "null"
              }
            ]
          },
          "part_of_speech": {
            "description": "Part of speech of the form.",
            "example": "NOUN",
            "oneOf": [
              {
                "$ref": "#/components/schemas/PartOfSpeech"
              },
              {
                "type": "null"
              }
            ]
          },
          "grammatical_number": {
            "description": "Grammatical number of the form.",
            "example": "SINGULAR",
            "oneOf": [
              {
                "$ref": "#/components/schemas/GrammaticalNumber"
              },
              {
                "type": "null"
              }
            ]
          },
          "grammatical_gender": {
            "description": "Grammatical gender of the form.",
            "example": "FEMININE",
            "oneOf": [
              {
                "$ref": "#/components/schemas/GrammaticalGender"
              },
              {
                "type": "null"
              }
            ]
          },
          "matching": {
            "$ref": "#/components/schemas/Matching",
            "description": "How the form is matched against text.",
            "example": "AUTOMATIC"
          },
          "match_expression": {
            "type": [
              "string",
              "null"
            ],
            "description": "The regular expression a `CUSTOM` matching uses; null for every other matching."
          },
          "case_sensitivity": {
            "$ref": "#/components/schemas/CaseSensitivity",
            "description": "How the form is matched with regard to case.",
            "example": "SENSITIVE"
          },
          "created_at": {
            "type": "string",
            "format": "date-time",
            "description": "Timestamp when the form was created.",
            "example": "2025-01-15T10:30:00.123Z"
          },
          "updated_at": {
            "type": "string",
            "format": "date-time",
            "description": "Timestamp when the form was last updated.",
            "example": "2025-06-20T14:45:00.123Z"
          }
        },
        "required": [
          "case_sensitivity",
          "created_at",
          "form_type",
          "grammatical_gender",
          "grammatical_number",
          "id",
          "inherited_by",
          "language_code",
          "match_expression",
          "matching",
          "object_type",
          "part_of_speech",
          "term_id",
          "text",
          "updated_at",
          "usage_status"
        ]
      },
      "Error": {
        "type": "object",
        "description": "RFC 9457 problem details. `code` identifies the problem type (one per `type` URL); `errors` lists rejected fields or parameters; `required_permission` names the permission a 403 lacked.",
        "properties": {
          "type": {
            "type": "string",
            "description": "URL identifying the problem type and pointing to its documentation.",
            "example": "https://api.lingohub.com/errors/resource-not-found"
          },
          "title": {
            "type": "string",
            "description": "Short, constant summary of the problem type.",
            "example": "Resource not found"
          },
          "status": {
            "type": "integer",
            "format": "int32",
            "description": "HTTP status code.",
            "example": 404
          },
          "detail": {
            "type": "string",
            "description": "Human-readable explanation of this occurrence of the problem.",
            "example": "Resource with ID 'pr_0197c8f2-5a6b-7cde-8f12-3456789abcde' was not found."
          },
          "instance": {
            "type": "string",
            "description": "Path of the request that produced the problem.",
            "example": "/v2/projects/pr_0197c8f2-5a6b-7cde-8f12-3456789abcde"
          },
          "code": {
            "$ref": "#/components/schemas/ErrorCode",
            "description": "Machine-readable problem type.",
            "example": "resource_not_found"
          },
          "request_id": {
            "type": "string",
            "description": "Correlation id of the request, also returned in the `X-Request-ID` header. Quote it when contacting support.",
            "example": "f47ac10b-58cc-4372-a567-0e02b2c3d479"
          },
          "errors": {
            "type": "array",
            "description": "Rejected fields or parameters. Present when the problem concerns specific fields or parameters.",
            "example": [
              {
                "detail": "must be at least 2 characters long",
                "pointer": "#/name",
                "parameter": "limit",
                "code": "minLength"
              }
            ],
            "items": {
              "$ref": "#/components/schemas/FieldError"
            }
          },
          "required_permission": {
            "$ref": "#/components/schemas/RequiredPermission",
            "description": "The permission the API key lacks. Present on 403 responses."
          }
        },
        "required": [
          "code",
          "detail",
          "instance",
          "request_id",
          "status",
          "title",
          "type"
        ]
      },
      "ErrorCode": {
        "type": "string",
        "description": "Machine-readable problem type of a V2 error response. Each code has a fixed HTTP status and documentation at its `type` URL.",
        "enum": [
          "invalid_json",
          "invalid_parameter",
          "missing_parameter",
          "unknown_parameter",
          "invalid_filter",
          "invalid_cursor",
          "bad_request",
          "missing_api_key",
          "invalid_api_key",
          "expired_api_key",
          "revoked_api_key",
          "disabled_api_key",
          "insufficient_permissions",
          "resource_not_found",
          "route_not_found",
          "method_not_allowed",
          "not_acceptable",
          "precondition_failed",
          "content_too_large",
          "unsupported_media_type",
          "already_exists",
          "idempotency_outcome_unknown",
          "idempotency_key_in_use",
          "stack_not_empty",
          "branch_not_ready",
          "backup_not_ready",
          "backup_in_use",
          "default_branch_protected",
          "owner_membership_protected",
          "source_language_protected",
          "branch_limit_reached",
          "context_image_limit_reached",
          "automation_limit_reached",
          "translation_order_pending",
          "git_integration_not_configured",
          "branch_git_integration_not_configured",
          "git_integration_unauthorized",
          "conflict",
          "validation_failed",
          "idempotency_key_mismatch",
          "rate_limit_exceeded",
          "internal_error",
          "upstream_error",
          "service_unavailable",
          "upstream_timeout"
        ]
      },
      "FieldError": {
        "type": "object",
        "description": "A rejected field or parameter. `pointer` locates a body field (RFC 6901 JSON Pointer), `parameter` a query, path or header parameter or a field of a multipart upload; both are set for a position inside a JSON-valued parameter such as `filter`.",
        "properties": {
          "detail": {
            "type": "string",
            "description": "Human-readable description of the problem.",
            "example": "must be at least 2 characters long"
          },
          "pointer": {
            "type": [
              "string",
              "null"
            ],
            "description": "JSON Pointer to the offending body field, or to the position inside a JSON-valued parameter.",
            "example": "#/name"
          },
          "parameter": {
            "type": [
              "string",
              "null"
            ],
            "description": "Name of the offending query, path or header parameter, or of the multipart form field.",
            "example": "limit"
          },
          "code": {
            "$ref": "#/components/schemas/FieldErrorCode",
            "description": "Why the field or parameter was rejected.",
            "example": "minLength"
          }
        },
        "required": [
          "code",
          "detail",
          "parameter",
          "pointer"
        ]
      },
      "FieldErrorCode": {
        "type": "string",
        "description": "Why a field or parameter was rejected: the JSON Schema keyword of the violated rule, or one of the documented rules that no schema can express.",
        "enum": [
          "required",
          "type",
          "enum",
          "minLength",
          "maxLength",
          "minimum",
          "maximum",
          "pattern",
          "format",
          "additionalProperties",
          "minItems",
          "maxItems",
          "uniqueItems",
          "already_exists",
          "not_found",
          "not_supported",
          "unsupported_file_extension",
          "file_too_large",
          "file_empty",
          "invalid_archive",
          "empty_archive"
        ]
      },
      "RequiredPermission": {
        "type": "object",
        "description": "The permission the API key lacks, in the vocabulary of the API key permission settings.",
        "properties": {
          "scope": {
            "$ref": "#/components/schemas/PermissionScope",
            "description": "Where the permission applies.",
            "example": "STACK"
          },
          "target": {
            "$ref": "#/components/schemas/PermissionTarget",
            "description": "The area the permission governs.",
            "example": "SETTINGS"
          },
          "level": {
            "$ref": "#/components/schemas/PermissionLevel",
            "description": "The access level required.",
            "example": "MANAGE"
          }
        },
        "required": [
          "level",
          "scope",
          "target"
        ]
      },
      "PermissionScope": {
        "type": "string",
        "description": "Where a permission applies: `WORKSPACE` permissions cover workspace-level resources, `STACK` permissions the resources of a stack (its projects, branches, resources, languages, ...).",
        "enum": [
          "WORKSPACE",
          "STACK"
        ]
      },
      "PermissionTarget": {
        "type": "string",
        "description": "The area a permission governs.",
        "enum": [
          "GENERAL",
          "BILLING_SUBSCRIPTION",
          "WORKSPACES",
          "MEMBERS",
          "PLUGINS_INTEGRATIONS",
          "LOGS",
          "API_ACCESS",
          "STACKS",
          "TRANSLATION_ORDERS",
          "WORK_REPORTS",
          "STYLE_GUIDES",
          "GLOSSARIES",
          "TRANSLATION_MEMORIES",
          "LABELS",
          "AI_TRANSLATION",
          "QUICK_TRANSLATIONS",
          "SETTINGS",
          "ACTIVITIES",
          "RESOURCES",
          "CONTEXT_IMAGES",
          "LANGUAGES",
          "SEGMENT_KEYS",
          "SEGMENTS",
          "SEGMENT_TEXTS"
        ]
      },
      "PermissionLevel": {
        "type": "string",
        "description": "Access level of a permission: `MANAGE` includes `WRITE` and `VIEW`.",
        "enum": [
          "NO_ACCESS",
          "VIEW",
          "WRITE",
          "MANAGE"
        ]
      }
    },
    "headers": {
      "ETag": {
        "description": "Opaque strong validator for this representation. Keep its quotation marks and use it as If-Match on a documented conditional write. A replay carries the original ETag, which may now be stale.",
        "schema": {
          "type": "string"
        }
      },
      "RateLimit": {
        "description": "State of the rate-limit policy currently closest to rejection (IETF draft-ietf-httpapi-ratelimit-headers): the quoted policy name with `r` = requests remaining right now and `t` = seconds until the full quota is available again. Example: `\"api-key\";r=42;t=7`. Advisory: absent when the request fails authentication or the limiter state is momentarily unknown.",
        "schema": {
          "type": "string"
        }
      },
      "RateLimit-Policy": {
        "description": "The rate-limit policies applied to the request: each quoted policy name with `q` = sustained request quota per window of `w` seconds. Example: `\"api-key\";q=180;w=60, \"workspace\";q=600;w=60`. Advisory: absent when the request fails authentication or the limiter state is momentarily unknown.",
        "schema": {
          "type": "string"
        }
      },
      "Retry-After": {
        "description": "Seconds to wait before retrying.",
        "schema": {
          "type": "integer",
          "format": "int32"
        }
      }
    },
    "responses": {
      "BadRequest": {
        "description": "The request is malformed: an unknown or invalid query parameter, an invalid id in the path, or a body that is not valid JSON. `code` names the problem, `errors` the parameter or field.",
        "headers": {
          "RateLimit": {
            "$ref": "#/components/headers/RateLimit"
          },
          "RateLimit-Policy": {
            "$ref": "#/components/headers/RateLimit-Policy"
          }
        },
        "content": {
          "application/problem+json": {
            "schema": {
              "$ref": "#/components/schemas/Error"
            }
          }
        }
      },
      "Unauthorized": {
        "description": "Invalid or missing API key.",
        "content": {
          "application/problem+json": {
            "schema": {
              "$ref": "#/components/schemas/Error"
            }
          }
        }
      },
      "Forbidden": {
        "description": "Insufficient permissions.",
        "headers": {
          "RateLimit": {
            "$ref": "#/components/headers/RateLimit"
          },
          "RateLimit-Policy": {
            "$ref": "#/components/headers/RateLimit-Policy"
          }
        },
        "content": {
          "application/problem+json": {
            "schema": {
              "$ref": "#/components/schemas/Error"
            }
          }
        }
      },
      "NotFound": {
        "description": "The resource does not exist, or the API key cannot see it.",
        "headers": {
          "RateLimit": {
            "$ref": "#/components/headers/RateLimit"
          },
          "RateLimit-Policy": {
            "$ref": "#/components/headers/RateLimit-Policy"
          }
        },
        "content": {
          "application/problem+json": {
            "schema": {
              "$ref": "#/components/schemas/Error"
            }
          }
        }
      },
      "PreconditionFailed": {
        "description": "The current representation does not match If-Match (`precondition_failed`). No change was applied.",
        "headers": {
          "RateLimit": {
            "$ref": "#/components/headers/RateLimit"
          },
          "RateLimit-Policy": {
            "$ref": "#/components/headers/RateLimit-Policy"
          }
        },
        "content": {
          "application/problem+json": {
            "schema": {
              "$ref": "#/components/schemas/Error"
            }
          }
        }
      },
      "TooManyRequests": {
        "description": "The API rate limit was exceeded. Wait for the number of seconds given in the Retry-After header, then retry.",
        "headers": {
          "Retry-After": {
            "$ref": "#/components/headers/Retry-After"
          },
          "RateLimit": {
            "$ref": "#/components/headers/RateLimit"
          },
          "RateLimit-Policy": {
            "$ref": "#/components/headers/RateLimit-Policy"
          }
        },
        "content": {
          "application/problem+json": {
            "schema": {
              "$ref": "#/components/schemas/Error"
            }
          }
        }
      },
      "InternalServerError": {
        "description": "An unexpected internal server error occurred.",
        "headers": {
          "RateLimit": {
            "$ref": "#/components/headers/RateLimit"
          },
          "RateLimit-Policy": {
            "$ref": "#/components/headers/RateLimit-Policy"
          }
        },
        "content": {
          "application/problem+json": {
            "schema": {
              "$ref": "#/components/schemas/Error"
            }
          }
        }
      },
      "ServiceUnavailable": {
        "description": "The service is temporarily unavailable. Retry after the number of seconds in the Retry-After header.",
        "headers": {
          "Retry-After": {
            "$ref": "#/components/headers/Retry-After"
          },
          "RateLimit": {
            "$ref": "#/components/headers/RateLimit"
          },
          "RateLimit-Policy": {
            "$ref": "#/components/headers/RateLimit-Policy"
          }
        },
        "content": {
          "application/problem+json": {
            "schema": {
              "$ref": "#/components/schemas/Error"
            }
          }
        }
      }
    },
    "securitySchemes": {
      "bearerAuth": {
        "type": "http",
        "description": "API key authentication. Create API keys in your LingoHub workspace settings. Keys use the `lh-api_` prefix. Pass the full key as the Bearer token.",
        "scheme": "bearer"
      }
    }
  }
}
````
