# Set style guide language rules

`PUT https://api.lingohub.com/v2/style-guides/{styleGuideId}/rules/{languageCode}`

LingoHub API V2 (Beta) · [Style Guide Language Rules](https://developers.lingohub.com/reference/v2/operations/tags/style-guide-language-rules.md) · operation `setStyleGuideLanguageRules`

Sets the style guide's rules for one language, replacing all it had: a field left out or null is not set, and for formality, voice and complexity the general rule then applies. The language must be a supported locale; rules apply to exactly this code. Honorific levels only apply to Japanese and Korean. Send the ETag from getStyleGuideLanguageRules as If-Match to make sure nobody changed them; `If-Match: *` only replaces existing rules. Requires workspace-level style guides management permission.

## Parameters

| Parameter | In | Required | Type | Description |
| --- | --- | --- | --- | --- |
| `styleGuideId` | path | yes | string | Unique identifier of the style guide. |
| `languageCode` | path | yes | string | Language code that uniquely identifies a locale |
| `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 PUT \
  --url https://api.lingohub.com/v2/style-guides/sg_0197c8f2-5a6b-7cde-8f12-3456789abcde/rules/en-US \
  --header 'Authorization: Bearer YOUR_API_KEY' \
  --header 'Content-Type: application/json' \
  --data '{
  "formality": "FORMAL",
  "date_format": "EU_FORMAT",
  "time_format": "TIME_24H",
  "decimal_separator": "COMMA",
  "grouping_separator": "DOT",
  "quotes_format": "QUOTES_GERMAN",
  "oxford_comma": "NOT_SPECIFIED",
  "voice": "ACTIVE",
  "honorific_level_japanese": "POLITE",
  "honorific_level_korean": "POLITE",
  "gender_inclusiveness": "GENDER_NEUTRAL",
  "language_complexity": "STANDARD"
}'
```

## Responses

- `200`: The language rules.
- `400`: 
- `401`: 
- `403`: 
- `404`: 
- `412`: 
- `422`: The language isn't a supported locale (`enum` on `languageCode`), or an honorific level is set for a language other than Japanese or Korean (`not_supported`).
- `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": "Style Guide Language Rules",
      "description": "Override a style guide's rules for a single language."
    }
  ],
  "paths": {
    "/v2/style-guides/{styleGuideId}/rules/{languageCode}": {
      "put": {
        "tags": [
          "Style Guide Language Rules"
        ],
        "summary": "Set style guide language rules",
        "description": "Sets the style guide's rules for one language, replacing all it had: a field left out or null is not set, and for formality, voice and complexity the general rule then applies. The language must be a supported locale; rules apply to exactly this code. Honorific levels only apply to Japanese and Korean. Send the ETag from getStyleGuideLanguageRules as If-Match to make sure nobody changed them; `If-Match: *` only replaces existing rules. Requires workspace-level style guides management permission.",
        "operationId": "setStyleGuideLanguageRules",
        "parameters": [
          {
            "name": "styleGuideId",
            "in": "path",
            "description": "Unique identifier of the style guide.",
            "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 style guide, a valid value would be : sg_0197c8f2-5a6b-7cde-8f12-3456789abcde",
              "pattern": "^sg_[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": "sg_0197c8f2-5a6b-7cde-8f12-3456789abcde"
          },
          {
            "name": "languageCode",
            "in": "path",
            "description": "Language code that uniquely identifies a locale",
            "required": true,
            "schema": {
              "type": "string",
              "description": "Language code that uniquely identifies a locale. Valid examples would be 'en', 'en-GB', 'de', 'de-DE' etc. according to [ISO 639-1](https://en.wikipedia.org/wiki/List_of_ISO_639_language_codes)."
            },
            "example": "en-US"
          },
          {
            "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/SetStyleGuideLanguageRules"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "The language rules.",
            "headers": {
              "RateLimit": {
                "$ref": "#/components/headers/RateLimit"
              },
              "RateLimit-Policy": {
                "$ref": "#/components/headers/RateLimit-Policy"
              }
            },
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/StyleGuideLanguageRules"
                }
              }
            }
          },
          "400": {
            "$ref": "#/components/responses/BadRequest"
          },
          "401": {
            "$ref": "#/components/responses/Unauthorized"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          },
          "412": {
            "$ref": "#/components/responses/PreconditionFailed"
          },
          "422": {
            "description": "The language isn't a supported locale (`enum` on `languageCode`), or an honorific level is set for a language other than Japanese or Korean (`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": {
      "SetStyleGuideLanguageRules": {
        "type": "object",
        "additionalProperties": false,
        "description": "Request body to set per-language override rules that refine the global style guide settings for a specific language. Creates the rule set if it does not exist, otherwise replaces it. Omitted fields are cleared.",
        "properties": {
          "formality": {
            "description": "Language-specific formality override.",
            "example": "FORMAL",
            "oneOf": [
              {
                "$ref": "#/components/schemas/StyleGuideFormality"
              },
              {
                "type": "null"
              }
            ]
          },
          "date_format": {
            "description": "Preferred date format for this language.",
            "example": "EU_FORMAT",
            "oneOf": [
              {
                "$ref": "#/components/schemas/StyleGuideDateFormat"
              },
              {
                "type": "null"
              }
            ]
          },
          "time_format": {
            "description": "Preferred time format for this language.",
            "example": "TIME_24H",
            "oneOf": [
              {
                "$ref": "#/components/schemas/StyleGuideTimeFormat"
              },
              {
                "type": "null"
              }
            ]
          },
          "decimal_separator": {
            "description": "Preferred decimal separator for this language.",
            "example": "COMMA",
            "oneOf": [
              {
                "$ref": "#/components/schemas/StyleGuideDecimalSeparator"
              },
              {
                "type": "null"
              }
            ]
          },
          "grouping_separator": {
            "description": "Preferred grouping separator for numeric values in this language.",
            "example": "DOT",
            "oneOf": [
              {
                "$ref": "#/components/schemas/StyleGuideGroupingSeparator"
              },
              {
                "type": "null"
              }
            ]
          },
          "quotes_format": {
            "description": "Preferred quotation mark style for this language.",
            "example": "QUOTES_GERMAN",
            "oneOf": [
              {
                "$ref": "#/components/schemas/StyleGuideQuotesFormat"
              },
              {
                "type": "null"
              }
            ]
          },
          "oxford_comma": {
            "description": "Preferred serial comma usage for this language.",
            "example": "NOT_SPECIFIED",
            "oneOf": [
              {
                "$ref": "#/components/schemas/StyleGuideOxfordComma"
              },
              {
                "type": "null"
              }
            ]
          },
          "voice": {
            "description": "Language-specific voice preference.",
            "example": "ACTIVE",
            "oneOf": [
              {
                "$ref": "#/components/schemas/StyleGuideVoice"
              },
              {
                "type": "null"
              }
            ]
          },
          "honorific_level_japanese": {
            "description": "Honorific level for Japanese translations.",
            "example": "POLITE",
            "oneOf": [
              {
                "$ref": "#/components/schemas/StyleGuideHonorificLevelJapanese"
              },
              {
                "type": "null"
              }
            ]
          },
          "honorific_level_korean": {
            "description": "Honorific level for Korean translations.",
            "example": "POLITE",
            "oneOf": [
              {
                "$ref": "#/components/schemas/StyleGuideHonorificLevelKorean"
              },
              {
                "type": "null"
              }
            ]
          },
          "gender_inclusiveness": {
            "description": "Gender inclusiveness preference for this language.",
            "example": "GENDER_NEUTRAL",
            "oneOf": [
              {
                "$ref": "#/components/schemas/StyleGuideGenderInclusiveness"
              },
              {
                "type": "null"
              }
            ]
          },
          "language_complexity": {
            "description": "Language complexity level for this language.",
            "example": "STANDARD",
            "oneOf": [
              {
                "$ref": "#/components/schemas/StyleGuideLanguageComplexity"
              },
              {
                "type": "null"
              }
            ]
          }
        }
      },
      "StyleGuideFormality": {
        "type": "string",
        "description": "Defines the desired level of formality in language, ranging from formal to informal.",
        "enum": [
          "NOT_SPECIFIED",
          "FORMAL",
          "INFORMAL"
        ]
      },
      "StyleGuideDateFormat": {
        "type": "string",
        "description": "Specifies various date formats for formatting and parsing dates, covering common standards and regional conventions.",
        "enum": [
          "NOT_SPECIFIED",
          "ISO_8601",
          "US_FORMAT",
          "EU_FORMAT",
          "UK_FORMAT",
          "CHINA_FORMAT",
          "JAPAN_FORMAT",
          "KOREA_FORMAT",
          "SHORT_FORMAT",
          "LONG_FORMAT"
        ]
      },
      "StyleGuideTimeFormat": {
        "type": "string",
        "description": "Specifies various time formats for formatting and parsing time values.",
        "enum": [
          "NOT_SPECIFIED",
          "TIME_24H",
          "TIME_12H"
        ]
      },
      "StyleGuideDecimalSeparator": {
        "type": "string",
        "description": "Defines the character used as decimal separator in numeric values.",
        "enum": [
          "NOT_SPECIFIED",
          "DOT",
          "COMMA"
        ]
      },
      "StyleGuideGroupingSeparator": {
        "type": "string",
        "description": "Defines the character used for grouping digits in numeric values.",
        "enum": [
          "NOT_SPECIFIED",
          "NONE",
          "COMMA",
          "DOT",
          "SPACE_LIKE",
          "APOSTROPHE"
        ]
      },
      "StyleGuideQuotesFormat": {
        "type": "string",
        "description": "Defines different typographical styles for quotation marks, accommodating various international and stylistic conventions.",
        "enum": [
          "NOT_SPECIFIED",
          "QUOTES_ENGLISH",
          "QUOTES_SINGLE",
          "QUOTES_GERMAN",
          "QUOTES_FRENCH",
          "QUOTES_SWISS",
          "QUOTES_GUILLEMET"
        ]
      },
      "StyleGuideOxfordComma": {
        "type": "string",
        "description": "Defines stylistic preferences for using the serial (Oxford) comma before the final conjunction in lists.",
        "enum": [
          "NOT_SPECIFIED",
          "OXFORD_COMMA",
          "NO_OXFORD_COMMA"
        ]
      },
      "StyleGuideVoice": {
        "type": "string",
        "description": "Specifies a preference for using either active or passive voice in writing.",
        "enum": [
          "NOT_SPECIFIED",
          "ACTIVE",
          "PASSIVE",
          "FLEXIBLE"
        ]
      },
      "StyleGuideHonorificLevelJapanese": {
        "type": "string",
        "description": "Defines the level of formality for the Japanese language, affecting verb conjugations and vocabulary choice.",
        "enum": [
          "NOT_SPECIFIED",
          "PLAIN",
          "POLITE",
          "HONORIFIC",
          "HUMBLE",
          "BUSINESS_POLITE"
        ]
      },
      "StyleGuideHonorificLevelKorean": {
        "type": "string",
        "description": "Defines the level of formality for the Korean language, which is crucial for correct social and business communication.",
        "enum": [
          "NOT_SPECIFIED",
          "PLAIN",
          "POLITE",
          "FORMAL_POLITE"
        ]
      },
      "StyleGuideGenderInclusiveness": {
        "type": "string",
        "description": "Defines preferences for gender expression in language, particularly for nouns and pronouns in gendered languages.",
        "enum": [
          "NOT_SPECIFIED",
          "MASCULINE_GENERIC",
          "FEMININE_GENERIC",
          "GENDER_NEUTRAL",
          "GENDER_INCLUSIVE"
        ]
      },
      "StyleGuideLanguageComplexity": {
        "type": "string",
        "description": "Defines the desired level of language complexity and simplicity for generated text.",
        "enum": [
          "NOT_SPECIFIED",
          "STANDARD",
          "PLAIN_LANGUAGE",
          "VERY_SIMPLE"
        ]
      },
      "StyleGuideLanguageRules": {
        "type": "object",
        "description": "Per-language override rules that refine the global style guide settings for a specific language.",
        "properties": {
          "object_type": {
            "type": "string",
            "description": "Always `STYLE_GUIDE_LANGUAGE_RULES`.",
            "enum": [
              "STYLE_GUIDE_LANGUAGE_RULES"
            ],
            "example": "STYLE_GUIDE_LANGUAGE_RULES"
          },
          "style_guide_id": {
            "type": "string",
            "description": "Unique identifier of the style guide the rules belong to.",
            "example": "sg_0197c8f2-5a6b-7cde-8f12-3456789abcde",
            "pattern": "^sg_[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",
            "description": "Language code the rules apply to.",
            "example": "de"
          },
          "formality": {
            "description": "Language-specific formality override.",
            "example": "FORMAL",
            "oneOf": [
              {
                "$ref": "#/components/schemas/StyleGuideFormality"
              },
              {
                "type": "null"
              }
            ]
          },
          "date_format": {
            "description": "Preferred date format for this language.",
            "example": "EU_FORMAT",
            "oneOf": [
              {
                "$ref": "#/components/schemas/StyleGuideDateFormat"
              },
              {
                "type": "null"
              }
            ]
          },
          "time_format": {
            "description": "Preferred time format for this language.",
            "example": "TIME_24H",
            "oneOf": [
              {
                "$ref": "#/components/schemas/StyleGuideTimeFormat"
              },
              {
                "type": "null"
              }
            ]
          },
          "decimal_separator": {
            "description": "Preferred decimal separator for this language.",
            "example": "COMMA",
            "oneOf": [
              {
                "$ref": "#/components/schemas/StyleGuideDecimalSeparator"
              },
              {
                "type": "null"
              }
            ]
          },
          "grouping_separator": {
            "description": "Preferred grouping separator for numeric values in this language.",
            "example": "DOT",
            "oneOf": [
              {
                "$ref": "#/components/schemas/StyleGuideGroupingSeparator"
              },
              {
                "type": "null"
              }
            ]
          },
          "quotes_format": {
            "description": "Preferred quotation mark style for this language.",
            "example": "QUOTES_GERMAN",
            "oneOf": [
              {
                "$ref": "#/components/schemas/StyleGuideQuotesFormat"
              },
              {
                "type": "null"
              }
            ]
          },
          "oxford_comma": {
            "description": "Preferred serial comma usage for this language.",
            "example": "NOT_SPECIFIED",
            "oneOf": [
              {
                "$ref": "#/components/schemas/StyleGuideOxfordComma"
              },
              {
                "type": "null"
              }
            ]
          },
          "voice": {
            "description": "Language-specific voice preference.",
            "example": "ACTIVE",
            "oneOf": [
              {
                "$ref": "#/components/schemas/StyleGuideVoice"
              },
              {
                "type": "null"
              }
            ]
          },
          "honorific_level_japanese": {
            "description": "Honorific level for Japanese translations.",
            "example": "POLITE",
            "oneOf": [
              {
                "$ref": "#/components/schemas/StyleGuideHonorificLevelJapanese"
              },
              {
                "type": "null"
              }
            ]
          },
          "honorific_level_korean": {
            "description": "Honorific level for Korean translations.",
            "example": "POLITE",
            "oneOf": [
              {
                "$ref": "#/components/schemas/StyleGuideHonorificLevelKorean"
              },
              {
                "type": "null"
              }
            ]
          },
          "gender_inclusiveness": {
            "description": "Gender inclusiveness preference for this language.",
            "example": "GENDER_NEUTRAL",
            "oneOf": [
              {
                "$ref": "#/components/schemas/StyleGuideGenderInclusiveness"
              },
              {
                "type": "null"
              }
            ]
          },
          "language_complexity": {
            "description": "Language complexity level for this language.",
            "example": "STANDARD",
            "oneOf": [
              {
                "$ref": "#/components/schemas/StyleGuideLanguageComplexity"
              },
              {
                "type": "null"
              }
            ]
          },
          "created_at": {
            "type": "string",
            "format": "date-time",
            "description": "Timestamp when the rules were created.",
            "example": "2025-01-15T10:30:00.123Z"
          },
          "updated_at": {
            "type": "string",
            "format": "date-time",
            "description": "Timestamp when the rules were last updated.",
            "example": "2025-06-20T14:45:00.123Z"
          }
        },
        "required": [
          "created_at",
          "date_format",
          "decimal_separator",
          "formality",
          "gender_inclusiveness",
          "grouping_separator",
          "honorific_level_japanese",
          "honorific_level_korean",
          "language_code",
          "language_complexity",
          "object_type",
          "oxford_comma",
          "quotes_format",
          "style_guide_id",
          "time_format",
          "updated_at",
          "voice"
        ]
      },
      "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": {
      "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"
      }
    }
  }
}
````
