@giveitsmaller/contracts 0.62.0 → 0.65.0

package/README.md

@@ -0,0 +1,34 @@
+# @giveitsmaller/contracts
+
+**Generated contract types for GISL (Give It Smaller).** Do not edit — this package is produced by
+`scripts/generate.py` in the `giveitsmaller-sdks` repo and regenerated on every contracts re-vendor.
+
+| | |
+|---|---|
+| Package version | `0.65.0` |
+| Generated from spec | **`v2.194.0`** |
+
+## Two version lines, and they are not comparable
+
+This package is on an **0.x** line. The contract it is generated from is on a **2.x** line. They
+count independently and nothing in either name says so, so:
+
+- `npm view` / `composer show` tells you the PACKAGE version, never the spec version.
+- To find the spec version, read **`gislContractsSpec`** in `package.json` (npm) or
+  **`extra.gisl-contracts-spec`** in `composer.json` (Composer), or the table above.
+
+⚠️ **If `gislContractsSpec` is absent, this package is 0.62.0 or older — it does NOT mean you have
+the wrong package.** The field was introduced after 0.62.0.
+
+## What is in here
+
+- `openapi/api.yaml`, `asyncapi/events.yaml` — the specs themselves.
+- `dist/` — generated TypeScript types for both, plus the operation schemas.
+- `availability/availability.json` — per-endpoint availability. **`planned` means the endpoint is
+  declared but not necessarily implemented or routed**; check before building against it.
+
+## Related packages
+
+`giveitsmaller/contracts` on Packagist is the PHP build of this same generated output and shares
+these version numbers. `antoniocs/compression-contracts` is a DIFFERENT package — the 2.x Composer
+package carrying the spec for the PHP API — and its numbers are the spec numbers, not these.

package/accepted-options/accepted-options.json

@@ -1200,5 +1200,5 @@
       }
     }
   },
-  "schema_version": "2.191.0"
+  "schema_version": "2.194.0"
 }

package/accepted-options/image-output-routes.json

@@ -246,5 +246,5 @@
       "source_op": "compress"
     }
   },
-  "schema_version": "2.191.0"
+  "schema_version": "2.194.0"
 }

package/asyncapi/README.md

@@ -0,0 +1,16 @@
+# TypeScript -- AsyncAPI Event Models
+
+> **Auto-generated** -- do not edit manually. Changes will be overwritten on the next generation run.
+>
+> Regenerate with: `make project/generate-tests`
+
+## Source
+
+- **Spec:** `compression_contracts/asyncapi/events.yaml` (AsyncAPI 3.0)
+- **Generator:** [asyncapi/cli](https://www.asyncapi.com/tools/cli) 6.0.0
+  (Docker image: `asyncapi/cli:6.0.0`)
+- **Files:** 29
+
+## Contents
+
+TypeScript interfaces and enum types for async event models (operation requests, progress updates, results).

package/asyncapi/events.yaml

@@ -1,7 +1,7 @@
 asyncapi: 3.0.0
 info:
   title: GISL Compression Events
-  version: 3.25.3
+  version: 3.26.0
   description: |
     Asynchronous event contracts for the GISL (Give It Smaller) compression service.
 
@@ -4054,7 +4054,150 @@ components:
         Stored in database as part of the Operation entity.
 
         **Important**: This message MUST always be sent, whether the operation
-        succeeds or fails. It is the definitive signal that processing is complete.
+        succeeds or fails. It is the signal that an ATTEMPT at processing has
+        finished.
+
+        ⚠️ **It was previously described as "the definitive signal that
+        processing is complete". That is no longer accurate and the correction
+        matters:** a terminal result is definitive about the attempt that
+        produced it, not about the operation, because a second attempt can
+        follow and produce a second terminal result. See the supersession rule
+        below.
+
+        ## ⚠️ AN OPERATION MAY DELIVER MORE THAN ONE TERMINAL RESULT
+
+        Delivery is **at least once**, and that applies to the terminal event
+        itself. A consumer MUST be prepared for a second `OperationResult`
+        carrying the same `operation_id`.
+
+        **The known mechanism** (`compression_lambdas`, CODE READ re-verified at
+        HEAD 2026-08-11 — **not a staging measurement**, and contracts has not
+        measured it either): `SqsHandler` publishes a terminal `failed` result
+        and *then* returns a `BatchItemFailure`. SQS redelivers, the operation
+        reruns, and a second terminal event lands — `completed` if the retry
+        succeeds. **The first `failed` is never retracted.**
+
+        **FIFO deduplication does not collapse the pair**, and the reason is the
+        5-minute dedup window against the queue visibility timeouts: measured in
+        `compression_terraform` on 2026-08-13, those are **6× the Lambda
+        timeout — 1620s (27 min) fast, 3240s (54 min) medium, 4860s (81 min)
+        slow**. The smallest is over five times the dedup window, so redelivery
+        cannot land inside it.
+
+        ⚠️ **Two corrections to how this was first written here, both from
+        numbers relayed rather than run.** It said the redelivery interval is
+        "≥90 minutes" — **the maximum is 81 and the image/document path is 27**.
+        And it said the payloads "are not byte-identical anyway because COGS
+        metrics are stamped per invocation" — **per-invocation stamping does not
+        GUARANTEE difference**, since two runs can measure the same duration and
+        memory. The dedup argument rests on the window alone; the byte
+        difference is a likelihood, not a mechanism, and it is not load-bearing.
+
+        ### The rule: `completed` supersedes `failed`, REGARDLESS OF ARRIVAL ORDER
+
+        For a given `operation_id`:
+
+        1. **A `completed` result supersedes a `failed` result**, whichever
+           arrives first. A consumer that has recorded a failure and then
+           receives a completion MUST treat the operation as completed.
+        2. **A `completed` never supersedes another `completed`.** Keep the
+           first; a second is a duplicate delivery of the same outcome.
+        3. **Two `failed` results are NOT ordered by this contract.** Keep the
+           first `error_code` and record that another arrived. See the limit
+           below — this is the case the contract cannot yet decide, and saying
+           so is deliberate.
+
+        ### Supersession replaces the WHOLE result, not just the status
+
+        When a `completed` supersedes a `failed`, the superseding result is
+        authoritative **in its entirety**:
+
+        - `error_code`, `error_message` and `is_retryable` from the superseded
+          failure are **discarded**. ⚠️ Retaining them is the obvious bug: an
+          operation reading `status: completed` next to a stale
+          `error_code: timeout` is a record no consumer can interpret, and each
+          one would invent a different reconciliation.
+        - `metrics`, `outputs` and every output field are **the superseding
+          result's**. They are **not merged and not aggregated** — the two sets
+          describe two different invocations, and averaging or summing them
+          would produce a number that describes neither.
+        - If the superseded result is retained for audit, it must be stored
+          **as a separate record**, never merged field-wise into the surviving
+          one.
+
+        ⚠️ **NOT by arrival order, and not by any clock.** Rule 1 is decidable
+        from `status` alone, which is why it works today with no new field: the
+        only known producer of a second terminal is a retry *after* a failure,
+        so `failed` → `completed` is the only transition it generates. A rule
+        that depended on ordering would be undecidable on this message today —
+        see below.
+
+        ### Metric disagreement is NOT evidence of supersession
+
+        Two terminal results for one operation **may disagree on `metrics`**, and
+        that is expected rather than anomalous: COGS fields (`billed_duration_ms`,
+        `memory_mb`, `fargate_runtime_ms`, `duration_ms`) are stamped **per
+        invocation**, so a retry legitimately reports different numbers for the
+        same logical work.
+
+        **A consumer MUST NOT read metric disagreement as evidence that one
+        result supersedes the other.** Supersession is decided by the rule above
+        and by nothing else. Using metrics to arbitrate would make the answer
+        depend on how long a machine happened to take.
+
+        ### 🔴 THE MISSING FIELD, RECORDED AS A FINDING
+
+        **There is no producer-stamped ordering field on `OperationResult`
+        today.** No attempt counter, no producer timestamp, no sequence number —
+        `job_id`, `operation_id`, `operation_type`, `status` and the payload, and
+        nothing that says *which invocation produced this*.
+
+        That absence is why rule 3 exists: **two failures cannot be ordered, and
+        the contract does not pretend otherwise.** Telling consumers to fall back
+        on arrival order would be worse than admitting it — SNS/SQS ordering is a
+        transport property, and a rule that reads it as producer intent is wrong
+        in a way no consumer can detect.
+
+        **The field this needs is an `attempt` counter** — monotonically
+        increasing per `operation_id`, stamped by the producer — because it does
+        not depend on a clock, and two invocations are tens of minutes apart in
+        wall time (27–81 minutes of visibility timeout, measured above) but
+        ADJACENT in attempt number. **Not declared here**: the producer
+        must confirm it can supply it (SQS exposes `ApproximateReceiveCount` to
+        the handler, which is a candidate, not a decision). Specifying a field
+        the producer has not agreed to emit is how a contract acquires a
+        promise nothing keeps.
+
+        Once `attempt` exists, higher wins, and it subsumes rules 1–3.
+
+        ### 🔴 THE PARENT IS NOT COVERED BY THIS RULE, AND THAT IS A GAP
+
+        Consuming an `OperationResult` does not stop at the operation: it
+        derives Job and Workflow status, and `GET /api/workflows/{id}/events`
+        **closes the SSE stream once the workflow reaches a terminal state**.
+
+        ⇒ **A first `failed` can terminalise the parent and disconnect the
+        client BEFORE the superseding `completed` arrives.** Operation-level
+        supersession then repairs the record while the caller who was watching
+        has already been told the workflow failed and has had its stream closed.
+
+        **This contract does NOT specify:**
+
+        - whether a workflow that reached a terminal state may return to a
+          non-terminal one when a superseding `completed` lands;
+        - what a closed SSE stream owes a client afterwards — **nothing here
+          reopens it**, and a client that did not poll will not learn;
+        - whether a re-derived parent status emits any event at all.
+
+        **Those are api's to decide** (their `U8G8ECRD` / `cfaGq9Xt`), and the
+        gap is recorded here rather than resolved, because a rule invented in
+        this repo for behaviour implemented in another is the shape that
+        produced the false paragraph corrected above.
+
+        ⚠️ **Until it is decided, a consumer that treats a workflow-level
+        `failed` as final is CORRECT per this contract and may still be wrong in
+        fact.** Saying so is the honest position; implying the operation-level
+        rule fixes the parent would not be.
 
         ## Single-output vs multi-output completion
 
@@ -5427,13 +5570,54 @@ components:
     ErrorCode:
       type: string
       description: |
+        ⚠️ **A CODE DECLARED HERE IS AN UPPER BOUND, NOT A GUARANTEE THAT ANY
+        WORKER CAN SEND IT.** Declaring a value in this enum does not make it
+        emittable: the path is contract → SDK regeneration → **each consumer
+        bumping its own pinned models ref** → only then can the value reach the
+        wire. **This repo cannot see where any code sits on that path**, because
+        the pin lives in the consumer.
+
+        Measured 2026-08-12 for one consumer (`compression_lambdas` at
+        `rust-models-v0.45.0`), by that consumer, since only they can:
+        **17 declared here · 15 available in their generated enum · 12 actually
+        emitted by a worker.** `input_too_large` was declared 2026-07-28 and is
+        one of the two that were **not yet available** — so a client handling it
+        would have been handling a case that could not occur, and would have
+        looked correct indefinitely.
+
+        **So a consumer MUST NOT infer from this list that a code can arrive.**
+        If you need to know, ask the producing repo — the answer is theirs and
+        is cheap for them; it is not derivable here. Deliberately not mechanised
+        (ticket [`E0sQkhMA`](https://trello.com/c/E0sQkhMA)): one measured answer
+        on request has been enough, and building the mechanism before the second
+        request is how a thing gets maintained for years because it exists.
+
         Machine-readable operation error code for categorization and retry logic.
         CLOSED typed set (the worker's `ErrorCode` enum); consumers SHOULD map known
         values and MUST degrade an unknown value to a generic reason (a future
-        contract version MAY add a variant; additive). Retryable codes are
-        auto-redriven (SQS) and EXHAUSTED before a failure surfaces to a consumer, so
-        a reported failure is always terminal — `is_retryable` only signals whether
-        re-submitting is worthwhile.
+        contract version MAY add a variant; additive).
+
+        🔴 **A REPORTED FAILURE IS NOT NECESSARILY THE LAST WORD.** This paragraph
+        previously said retryable codes are "auto-redriven (SQS) and EXHAUSTED
+        before a failure surfaces to a consumer, so a reported failure is always
+        terminal". **That is normative and it does not match the worker.**
+        `SqsHandler` publishes a terminal `failed` result and *then* returns a
+        `BatchItemFailure`; SQS redelivers, the operation reruns, and a second
+        terminal event lands — `completed` if the retry succeeds. **The first
+        `failed` is never retracted.**
+
+        ⚠️ **Source and its limit, stated so it is not laundered into something
+        stronger:** that mechanism is a **CODE READ of the worker, re-verified at
+        HEAD 2026-08-11 by `compression_lambdas` and relayed to this repo. It is
+        NOT a staging measurement, and contracts has not measured it either.**
+        The consumer rule below is written to be correct whether or not the
+        sequence occurs — a consumer that never receives a second terminal loses
+        nothing by following it.
+
+        **`is_retryable` is unchanged and still means what it says:** whether
+        re-submitting this operation is worthwhile. It is a property of the
+        error, not a statement about how many times the platform has already
+        tried. See `OperationResult` for the supersession rule.
 
         **Retryable errors** (transient — re-submitting may succeed):
         - s3_download_failed: Source file download failed
@@ -5441,7 +5625,17 @@ components:
         - out_of_memory: Worker ran out of memory
         - timeout: Operation exceeded its time cap
 
-        **Non-retryable errors** (terminal — won't clear on retry):
+        **Non-retryable errors** — and `is_retryable` IS the redelivery
+        condition, which makes these effectively final. `SqsHandler` returns a
+        `BatchItemFailure` **only when `error_code.is_retryable()`**; a
+        non-retryable failure is acknowledged and never redelivered, so no second
+        terminal result can follow it. ⇒ **A second terminal result can only
+        follow a RETRYABLE failure.** (Verified in
+        `compression_lambdas` `crates/shared/src/infra/handlers/sqs_handler.rs`
+        at `98309eba901fce4efd82908c143ba2b93002df51`. An earlier draft of this
+        paragraph said redelivery "is not conditioned on this field" — that was
+        wrong, and it was wrong in the direction that would have made consumers
+        defend against a case that cannot occur.)
         - invalid_format: Unsupported or corrupted file
         - format_mismatch: MIME type doesn't match content
         - decode_failed: Cannot decode/parse file

package/availability/README.md

@@ -0,0 +1,25 @@
+# TypeScript -- Availability Sidecar
+
+> **Auto-generated** -- do not edit manually. Changes will be overwritten on the next generation run.
+>
+> Regenerate with: `make project/generate-tests`
+
+## Source
+
+- **Spec:** `compression_contracts/availability/availability.json` (sidecar)
+- **Files:** 1 (`availability.json`)
+
+## Contents
+
+Capability matrix sidecar -- chain compatibility, capabilities_version,
+and per-feature availability metadata.
+
+## Access
+
+Import via the package subpath export:
+
+```ts
+import availability from '@giveitsmaller/contracts/availability/availability.json' with { type: 'json' };
+```
+
+The subpath is wired in `package.json` `exports` and the file is included in `files[]`.

package/availability/availability.json

@@ -1,5 +1,5 @@
 {
-  "capabilities_version": 180,
+  "capabilities_version": 181,
   "endpoints": {
     "DELETE /api/auth/account": {
       "auth": "required",
@@ -83,7 +83,19 @@
       "availability": "stable",
       "identity_scoped": true,
       "operation_id": "streamWorkflowEvents",
-      "required_tier": null
+      "required_tier": null,
+      "servers": [
+        {
+          "description": "Local development. Same origin as the rest of the API \u2014 local runs\ndo NOT reproduce the split-host topology, so a client that works\nlocally has **not** exercised the cross-origin path. Treat a local\npass as evidence about your code and not about the routing.\n",
+          "replaces": "http://localhost:8080",
+          "url": "http://localhost:8080"
+        },
+        {
+          "description": "Staging stream host. A SEPARATE PUBLIC ENTRY POINT from\n`api.staging.giveitsmaller.com`, which is why it is declared here\nrather than inherited: the API host fronts an integration with no\nresponse-streaming mode, and this is the only endpoint that needs\nstreaming.\n\n\u26a0\ufe0f **THIS HOST ALLOWS EXACTLY ONE CORS ORIGIN, AND IT IS A\nDIFFERENT POLICY FROM THE API HOST.** The stream stack sets\n`cors_allow_origin` (**singular**) to the frontend host alone, in\n**both** environments. The API host sets `cors_allow_origins`\n(**plural**) \u2014 and **the list differs BY ENVIRONMENT**:\n\n    staging api host   localhost:5173, localhost:3000, www.staging\u2026\n    prod    api host   www.giveitsmaller.com   \u2190 NO localhost, never had\n    both    stream     the frontend host only  (singular)\n\n\u21d2 **A BROWSER ON localhost CAN CALL THE STAGING API HOST AND\nCANNOT CALL EITHER STREAM HOST.** The break is **conditional on a\nlocal build choosing this host**: the frontend's local build leaves\n`VITE_SSE_BASE_URL` unset and falls back to the API host, so nothing\nbreaks today (measured by `compression_frontend`, 2026-08-14). **A\nclient that DOES point a localhost browser here is blocked, and the\nfailure arrives as a CORS error that reads as a configuration\nmistake in their own app.**\n\n**This is a local-development concern only; prod never permitted\nlocalhost on any host** (measured by `compression_terraform`,\n2026-08-14 \u2014 an earlier version of this note gave the staging list\nwithout saying it was staging's, which would have read as universal\nand turned a dev-experience issue into an apparent launch one).\n\n\u26a0\ufe0f **\"Just add another origin\" is not a CONFIG CHANGE here, and\nthe reason is our implementation rather than an AWS limit.** An API\nGateway **HTTP** API has a native, declarative CORS configuration\nthat takes a LIST and echoes whichever origin matches. A **REST**\nAPI has no equivalent declarative feature \u2014 the value is whatever\nthe preflight MOCK integration and the backend return \u2014 so\nmulti-origin support is possible but must be **built**\n(validate-the-Origin-then-echo), which is a change with its own\ncorrectness risk rather than an extra list entry.\n\n*(An earlier version of this note said a REST API simply cannot do\nit. That is wrong: AWS documents that for proxy integrations the\nBACKEND returns `Access-Control-Allow-Origin`, so per-origin\nresponses are available to anyone willing to implement them.\nStating a platform prohibition where an implementation choice\nexists closes a door that is open.)*\n\nThe credentialed case does foreclose the other escape: with\n`Allow-Credentials: true` the origin header cannot be `*`.\n\nThe same applies to embedded and third-party consumers, and to any\n**browser build of a published SDK**: `@giveitsmaller/sdk` ships a\nbrowser entry point whose client carries `streamEvents`, so this is\na published-surface limit rather than an internal one.\n\nA server-side caller is unaffected. **The origin list is a property\nof the deployed stack, not of this contract** \u2014 it is stated here\nbecause a client author reading only the URL cannot discover it, and\nit changes only in `compression_terraform`.\n\n\u26a0\ufe0f **AUTH ON THIS HOST IS CROSS-ORIGIN, AND `sessionAuth` IS THE\nONE THAT MAY NOT SURVIVE IT.** This operation advertises\n`bearerAuth`, `sessionAuth` and anonymous access \u2014 but the security\nlist describes what the ENDPOINT accepts, not what a browser can\ndeliver to a different origin.\n\n**Cookie domain scope is necessary and NOT sufficient.** A\ncredentialed cross-origin request additionally requires the client\nto opt in (`EventSource { withCredentials: true }`, or `fetch`\nwith `credentials: 'include'`) **and** the server to answer with\n`Access-Control-Allow-Credentials` and a non-wildcard origin. Bearer\nand capability headers likewise need the header to be permitted by\nthe preflight response.\n\n**None of that is verified by this contract, and contracts has not\nmeasured it.** \u21d2 **A browser client SHOULD prefer `bearerAuth` or\nthe anonymous capability header on this host**, and should treat\ncookie-based session auth over it as unproven until somebody\nmeasures a credentialed cross-origin stream.\n",
+          "replaces": "https://api.staging.giveitsmaller.com",
+          "url": "https://stream.staging.giveitsmaller.com"
+        }
+      ]
     },
     "GET /api/workflows/{id}/status": {
       "auth": "optional",
@@ -276,7 +288,7 @@
     },
     "POST /api/workflows/{id}/archive": {
       "auth": "required",
-      "availability": "stable",
+      "availability": "planned",
       "identity_scoped": true,
       "operation_id": "archiveWorkflow",
       "required_tier": null
@@ -290,7 +302,7 @@
     },
     "POST /api/workflows/{id}/restore": {
       "auth": "required",
-      "availability": "stable",
+      "availability": "planned",
       "identity_scoped": true,
       "operation_id": "restoreWorkflow",
       "required_tier": null
@@ -996,7 +1008,7 @@
           }
         },
         "document_epub": {
-          "max_input_size_bytes": 104857600,
+          "max_input_size_bytes": 209715200,
           "mimes": [
             "application/epub+zip"
           ],
@@ -1021,7 +1033,7 @@
           }
         },
         "document_odf": {
-          "max_input_size_bytes": 104857600,
+          "max_input_size_bytes": 209715200,
           "mimes": [
             "application/vnd.oasis.opendocument.text",
             "application/vnd.oasis.opendocument.spreadsheet",
@@ -1048,7 +1060,7 @@
           }
         },
         "document_office": {
-          "max_input_size_bytes": 104857600,
+          "max_input_size_bytes": 209715200,
           "mimes": [
             "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
             "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
@@ -5118,7 +5130,7 @@
       "sole_op": true
     }
   },
-  "schema_version": "2.191.0",
+  "schema_version": "2.194.0",
   "source_commit": null,
   "user_tier": null,
   "workflow_features": {

package/code-builder/code-builder-metadata.json

@@ -1200,7 +1200,7 @@
           }
         },
         "document_epub": {
-          "max_input_size_bytes": 104857600,
+          "max_input_size_bytes": 209715200,
           "media_group": "document",
           "mimes": [
             "application/epub+zip"
@@ -1249,7 +1249,7 @@
           }
         },
         "document_odf": {
-          "max_input_size_bytes": 104857600,
+          "max_input_size_bytes": 209715200,
           "media_group": "document",
           "mimes": [
             "application/vnd.oasis.opendocument.text",
@@ -1300,7 +1300,7 @@
           }
         },
         "document_office": {
-          "max_input_size_bytes": 104857600,
+          "max_input_size_bytes": 209715200,
           "media_group": "document",
           "mimes": [
             "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
@@ -7188,7 +7188,7 @@
     }
   },
   "preset_config_hash": "sha256:354814f7906f85be6a6ca5ede6c0722c83cdc058fd658a9bb2b0996520466c6d",
-  "schema_version": "2.191.0",
+  "schema_version": "2.194.0",
   "sdk_spec_version": "2.3.0",
-  "source_hash": "sha256:65108661e2b4bb6fc9c9b56f5dcb1274bf9cd3ac4addbcb2b34f86ec4e5d91aa"
+  "source_hash": "sha256:d7ff190cf08026ff0029b37b31ca48f6dcaa67827dfc46e1328a9cbb43aada31"
 }

package/dist/openapi/models/AccountLimitEntry.d.ts

@@ -2,7 +2,7 @@
  * GISL Compression API
  * REST API for the GISL (Give It Smaller) file compression and processing service.  **Architecture:** - Upload files to get a `file_id` - Create workflows referencing uploaded files with operations (compress, thumbnail, image_watermark, text_watermark, merge, archive, convert, custom_luma, audio_overlay, audio_watermark) - Poll status, stream SSE events, or receive webhook callbacks - Download results per operation output  **Response envelope:** All mutation and query endpoints return `{ success: true, data: {...} }` on success and `{ success: false, error: \"...\", details: [...] }` on failure. Exceptions: `GET /api/operations/schema` returns raw JSON (per-tier private caching with ETag revalidation per ADR-0002 + I3), health probes return flat objects, and `POST /api/contact` returns 204 with no body.  **Availability metadata.** This spec uses the `x-availability` vendor extension as **decorative documentation only**. Per [ADR-0001](../docs/decisions/0001-contract-first-availability.md) §1.5, the runtime endpoint `GET /api/operations/schema` (ticket I3) is the authoritative source; the sidecar `availability.json` (ticket I3b) is the authoritative companion (generated, never hand-edited; CI cross-checks runtime ⇄ sidecar). SDKs MUST NOT depend on `x-availability` reaching generated code — code-generators that surface vendor extensions may emit it as documentation, but consumers read availability from the runtime endpoint, not from the generated bindings.  The 5-value vocabulary (`stable | beta | experimental | planned | deprecated`) is defined in the `AvailabilityValue` schema. See `schemas/FORMAT.md` §Availability Taxonomy for the operational rules (parser obligation: absent = stable; per-enum-value granularity is the `per_value_availability` primitive landed via ticket I17).  **Localisation (per ticket [I26](https://trello.com/c/rcnqwgI4)).**  Error responses + paused/blocked workflow statuses carry a localised human-readable `message` alongside a stable, never-localised `message_key`. Machine-readable fields (`error`, enum values, status codes) stay canonical English.  - **Currently committed locales:** `en-GB` only (per ticket   [`4GKyuYo6`](https://trello.com/c/4GKyuYo6)). The I26 carrier   shape (`Accept-Language` + `Content-Language` + `Vary` headers +   `locale` envelope field + `message_key` + `message_params`) is   stable and exercised; the **catalog** of translated `message`   strings is en-GB-only at runtime today. Additional locales (e.g.   `pt-PT`) will be advertised by name when their catalogs ship —   the request/response carrier shape does NOT change when a new   locale lands. Treat unrequested locales as \"machine-code +   `message_key` path is committed; localised `message` prose is   not\" until this prose enumerates them by name. - **Request:** `Accept-Language` header per RFC 9110 §12.5.4 (q-value   negotiation supported). The server selects the best-match locale   from its supported list; falls back to `en-GB` when no match —   which, until additional catalogs land, is every non-`en-GB`   `Accept-Language`. - **Response:** `Content-Language: <locale>` echo on every localised   response; `Vary: Accept-Language` on every response (CDN/cache   correctness — different `Accept-Language` requests produce   different responses). `Vary` is emitted unconditionally so the   header contract does not flip when a second locale ships. - **Fallback locale:** `en-GB` (also the canonical locale for   `message_key` translations and English `message` prose). - **SDK guidance:** switch on `error` (machine code) for typed   error branches; surface `message_key` to client-side i18n   catalogs (SDK companion work tracked at X19, cross-repo);   display `message` for end-user UI; **never parse `message` for   control flow** — it changes per locale.  Carrier shape lives on `ErrorEnvelope` (envelope-level optional `message_key` + `message` + `locale` + `message_params`) and `ValidationErrorEnvelope` (also per-`details[]` entry). Existing 402 / 403 / 422 envelopes (`BalanceExhaustedResponse`, `FeatureNotAvailableResponse`, `FeatureTierRestrictedResponse`, `WorkflowPausedDetail`) inherit the convention.  **Upload thresholds (per tickets [u0ar7Yye](https://trello.com/c/u0ar7Yye) + [58nBQLWQ](https://trello.com/c/58nBQLWQ)).** Canonical upload constants (single-shot cap, multipart chunk size, multipart concurrency default, multipart first-chunk size) live on the `UploadThresholds` schema with `const:`-pinned values. SDK generators emit these as typed binding constants so frontend / API / SDKs reference one source of truth instead of hardcoding magic numbers. A runtime `GET /api/uploads/limits` endpoint for dynamic discovery (per-tier / per-environment overrides) is a deferred follow-up.
  *
- * The version of the OpenAPI document: 2.191.0
+ * The version of the OpenAPI document: 2.194.0
  *
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

package/dist/openapi/models/AccountLimitEntry.js

@@ -4,7 +4,7 @@
  * GISL Compression API
  * REST API for the GISL (Give It Smaller) file compression and processing service.  **Architecture:** - Upload files to get a `file_id` - Create workflows referencing uploaded files with operations (compress, thumbnail, image_watermark, text_watermark, merge, archive, convert, custom_luma, audio_overlay, audio_watermark) - Poll status, stream SSE events, or receive webhook callbacks - Download results per operation output  **Response envelope:** All mutation and query endpoints return `{ success: true, data: {...} }` on success and `{ success: false, error: \"...\", details: [...] }` on failure. Exceptions: `GET /api/operations/schema` returns raw JSON (per-tier private caching with ETag revalidation per ADR-0002 + I3), health probes return flat objects, and `POST /api/contact` returns 204 with no body.  **Availability metadata.** This spec uses the `x-availability` vendor extension as **decorative documentation only**. Per [ADR-0001](../docs/decisions/0001-contract-first-availability.md) §1.5, the runtime endpoint `GET /api/operations/schema` (ticket I3) is the authoritative source; the sidecar `availability.json` (ticket I3b) is the authoritative companion (generated, never hand-edited; CI cross-checks runtime ⇄ sidecar). SDKs MUST NOT depend on `x-availability` reaching generated code — code-generators that surface vendor extensions may emit it as documentation, but consumers read availability from the runtime endpoint, not from the generated bindings.  The 5-value vocabulary (`stable | beta | experimental | planned | deprecated`) is defined in the `AvailabilityValue` schema. See `schemas/FORMAT.md` §Availability Taxonomy for the operational rules (parser obligation: absent = stable; per-enum-value granularity is the `per_value_availability` primitive landed via ticket I17).  **Localisation (per ticket [I26](https://trello.com/c/rcnqwgI4)).**  Error responses + paused/blocked workflow statuses carry a localised human-readable `message` alongside a stable, never-localised `message_key`. Machine-readable fields (`error`, enum values, status codes) stay canonical English.  - **Currently committed locales:** `en-GB` only (per ticket   [`4GKyuYo6`](https://trello.com/c/4GKyuYo6)). The I26 carrier   shape (`Accept-Language` + `Content-Language` + `Vary` headers +   `locale` envelope field + `message_key` + `message_params`) is   stable and exercised; the **catalog** of translated `message`   strings is en-GB-only at runtime today. Additional locales (e.g.   `pt-PT`) will be advertised by name when their catalogs ship —   the request/response carrier shape does NOT change when a new   locale lands. Treat unrequested locales as \"machine-code +   `message_key` path is committed; localised `message` prose is   not\" until this prose enumerates them by name. - **Request:** `Accept-Language` header per RFC 9110 §12.5.4 (q-value   negotiation supported). The server selects the best-match locale   from its supported list; falls back to `en-GB` when no match —   which, until additional catalogs land, is every non-`en-GB`   `Accept-Language`. - **Response:** `Content-Language: <locale>` echo on every localised   response; `Vary: Accept-Language` on every response (CDN/cache   correctness — different `Accept-Language` requests produce   different responses). `Vary` is emitted unconditionally so the   header contract does not flip when a second locale ships. - **Fallback locale:** `en-GB` (also the canonical locale for   `message_key` translations and English `message` prose). - **SDK guidance:** switch on `error` (machine code) for typed   error branches; surface `message_key` to client-side i18n   catalogs (SDK companion work tracked at X19, cross-repo);   display `message` for end-user UI; **never parse `message` for   control flow** — it changes per locale.  Carrier shape lives on `ErrorEnvelope` (envelope-level optional `message_key` + `message` + `locale` + `message_params`) and `ValidationErrorEnvelope` (also per-`details[]` entry). Existing 402 / 403 / 422 envelopes (`BalanceExhaustedResponse`, `FeatureNotAvailableResponse`, `FeatureTierRestrictedResponse`, `WorkflowPausedDetail`) inherit the convention.  **Upload thresholds (per tickets [u0ar7Yye](https://trello.com/c/u0ar7Yye) + [58nBQLWQ](https://trello.com/c/58nBQLWQ)).** Canonical upload constants (single-shot cap, multipart chunk size, multipart concurrency default, multipart first-chunk size) live on the `UploadThresholds` schema with `const:`-pinned values. SDK generators emit these as typed binding constants so frontend / API / SDKs reference one source of truth instead of hardcoding magic numbers. A runtime `GET /api/uploads/limits` endpoint for dynamic discovery (per-tier / per-environment overrides) is a deferred follow-up.
  *
- * The version of the OpenAPI document: 2.191.0
+ * The version of the OpenAPI document: 2.194.0
  *
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

package/dist/openapi/models/AccountLimits.d.ts

@@ -2,7 +2,7 @@
  * GISL Compression API
  * REST API for the GISL (Give It Smaller) file compression and processing service.  **Architecture:** - Upload files to get a `file_id` - Create workflows referencing uploaded files with operations (compress, thumbnail, image_watermark, text_watermark, merge, archive, convert, custom_luma, audio_overlay, audio_watermark) - Poll status, stream SSE events, or receive webhook callbacks - Download results per operation output  **Response envelope:** All mutation and query endpoints return `{ success: true, data: {...} }` on success and `{ success: false, error: \"...\", details: [...] }` on failure. Exceptions: `GET /api/operations/schema` returns raw JSON (per-tier private caching with ETag revalidation per ADR-0002 + I3), health probes return flat objects, and `POST /api/contact` returns 204 with no body.  **Availability metadata.** This spec uses the `x-availability` vendor extension as **decorative documentation only**. Per [ADR-0001](../docs/decisions/0001-contract-first-availability.md) §1.5, the runtime endpoint `GET /api/operations/schema` (ticket I3) is the authoritative source; the sidecar `availability.json` (ticket I3b) is the authoritative companion (generated, never hand-edited; CI cross-checks runtime ⇄ sidecar). SDKs MUST NOT depend on `x-availability` reaching generated code — code-generators that surface vendor extensions may emit it as documentation, but consumers read availability from the runtime endpoint, not from the generated bindings.  The 5-value vocabulary (`stable | beta | experimental | planned | deprecated`) is defined in the `AvailabilityValue` schema. See `schemas/FORMAT.md` §Availability Taxonomy for the operational rules (parser obligation: absent = stable; per-enum-value granularity is the `per_value_availability` primitive landed via ticket I17).  **Localisation (per ticket [I26](https://trello.com/c/rcnqwgI4)).**  Error responses + paused/blocked workflow statuses carry a localised human-readable `message` alongside a stable, never-localised `message_key`. Machine-readable fields (`error`, enum values, status codes) stay canonical English.  - **Currently committed locales:** `en-GB` only (per ticket   [`4GKyuYo6`](https://trello.com/c/4GKyuYo6)). The I26 carrier   shape (`Accept-Language` + `Content-Language` + `Vary` headers +   `locale` envelope field + `message_key` + `message_params`) is   stable and exercised; the **catalog** of translated `message`   strings is en-GB-only at runtime today. Additional locales (e.g.   `pt-PT`) will be advertised by name when their catalogs ship —   the request/response carrier shape does NOT change when a new   locale lands. Treat unrequested locales as \"machine-code +   `message_key` path is committed; localised `message` prose is   not\" until this prose enumerates them by name. - **Request:** `Accept-Language` header per RFC 9110 §12.5.4 (q-value   negotiation supported). The server selects the best-match locale   from its supported list; falls back to `en-GB` when no match —   which, until additional catalogs land, is every non-`en-GB`   `Accept-Language`. - **Response:** `Content-Language: <locale>` echo on every localised   response; `Vary: Accept-Language` on every response (CDN/cache   correctness — different `Accept-Language` requests produce   different responses). `Vary` is emitted unconditionally so the   header contract does not flip when a second locale ships. - **Fallback locale:** `en-GB` (also the canonical locale for   `message_key` translations and English `message` prose). - **SDK guidance:** switch on `error` (machine code) for typed   error branches; surface `message_key` to client-side i18n   catalogs (SDK companion work tracked at X19, cross-repo);   display `message` for end-user UI; **never parse `message` for   control flow** — it changes per locale.  Carrier shape lives on `ErrorEnvelope` (envelope-level optional `message_key` + `message` + `locale` + `message_params`) and `ValidationErrorEnvelope` (also per-`details[]` entry). Existing 402 / 403 / 422 envelopes (`BalanceExhaustedResponse`, `FeatureNotAvailableResponse`, `FeatureTierRestrictedResponse`, `WorkflowPausedDetail`) inherit the convention.  **Upload thresholds (per tickets [u0ar7Yye](https://trello.com/c/u0ar7Yye) + [58nBQLWQ](https://trello.com/c/58nBQLWQ)).** Canonical upload constants (single-shot cap, multipart chunk size, multipart concurrency default, multipart first-chunk size) live on the `UploadThresholds` schema with `const:`-pinned values. SDK generators emit these as typed binding constants so frontend / API / SDKs reference one source of truth instead of hardcoding magic numbers. A runtime `GET /api/uploads/limits` endpoint for dynamic discovery (per-tier / per-environment overrides) is a deferred follow-up.
  *
- * The version of the OpenAPI document: 2.191.0
+ * The version of the OpenAPI document: 2.194.0
  *
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

package/dist/openapi/models/AccountLimits.js

@@ -4,7 +4,7 @@
  * GISL Compression API
  * REST API for the GISL (Give It Smaller) file compression and processing service.  **Architecture:** - Upload files to get a `file_id` - Create workflows referencing uploaded files with operations (compress, thumbnail, image_watermark, text_watermark, merge, archive, convert, custom_luma, audio_overlay, audio_watermark) - Poll status, stream SSE events, or receive webhook callbacks - Download results per operation output  **Response envelope:** All mutation and query endpoints return `{ success: true, data: {...} }` on success and `{ success: false, error: \"...\", details: [...] }` on failure. Exceptions: `GET /api/operations/schema` returns raw JSON (per-tier private caching with ETag revalidation per ADR-0002 + I3), health probes return flat objects, and `POST /api/contact` returns 204 with no body.  **Availability metadata.** This spec uses the `x-availability` vendor extension as **decorative documentation only**. Per [ADR-0001](../docs/decisions/0001-contract-first-availability.md) §1.5, the runtime endpoint `GET /api/operations/schema` (ticket I3) is the authoritative source; the sidecar `availability.json` (ticket I3b) is the authoritative companion (generated, never hand-edited; CI cross-checks runtime ⇄ sidecar). SDKs MUST NOT depend on `x-availability` reaching generated code — code-generators that surface vendor extensions may emit it as documentation, but consumers read availability from the runtime endpoint, not from the generated bindings.  The 5-value vocabulary (`stable | beta | experimental | planned | deprecated`) is defined in the `AvailabilityValue` schema. See `schemas/FORMAT.md` §Availability Taxonomy for the operational rules (parser obligation: absent = stable; per-enum-value granularity is the `per_value_availability` primitive landed via ticket I17).  **Localisation (per ticket [I26](https://trello.com/c/rcnqwgI4)).**  Error responses + paused/blocked workflow statuses carry a localised human-readable `message` alongside a stable, never-localised `message_key`. Machine-readable fields (`error`, enum values, status codes) stay canonical English.  - **Currently committed locales:** `en-GB` only (per ticket   [`4GKyuYo6`](https://trello.com/c/4GKyuYo6)). The I26 carrier   shape (`Accept-Language` + `Content-Language` + `Vary` headers +   `locale` envelope field + `message_key` + `message_params`) is   stable and exercised; the **catalog** of translated `message`   strings is en-GB-only at runtime today. Additional locales (e.g.   `pt-PT`) will be advertised by name when their catalogs ship —   the request/response carrier shape does NOT change when a new   locale lands. Treat unrequested locales as \"machine-code +   `message_key` path is committed; localised `message` prose is   not\" until this prose enumerates them by name. - **Request:** `Accept-Language` header per RFC 9110 §12.5.4 (q-value   negotiation supported). The server selects the best-match locale   from its supported list; falls back to `en-GB` when no match —   which, until additional catalogs land, is every non-`en-GB`   `Accept-Language`. - **Response:** `Content-Language: <locale>` echo on every localised   response; `Vary: Accept-Language` on every response (CDN/cache   correctness — different `Accept-Language` requests produce   different responses). `Vary` is emitted unconditionally so the   header contract does not flip when a second locale ships. - **Fallback locale:** `en-GB` (also the canonical locale for   `message_key` translations and English `message` prose). - **SDK guidance:** switch on `error` (machine code) for typed   error branches; surface `message_key` to client-side i18n   catalogs (SDK companion work tracked at X19, cross-repo);   display `message` for end-user UI; **never parse `message` for   control flow** — it changes per locale.  Carrier shape lives on `ErrorEnvelope` (envelope-level optional `message_key` + `message` + `locale` + `message_params`) and `ValidationErrorEnvelope` (also per-`details[]` entry). Existing 402 / 403 / 422 envelopes (`BalanceExhaustedResponse`, `FeatureNotAvailableResponse`, `FeatureTierRestrictedResponse`, `WorkflowPausedDetail`) inherit the convention.  **Upload thresholds (per tickets [u0ar7Yye](https://trello.com/c/u0ar7Yye) + [58nBQLWQ](https://trello.com/c/58nBQLWQ)).** Canonical upload constants (single-shot cap, multipart chunk size, multipart concurrency default, multipart first-chunk size) live on the `UploadThresholds` schema with `const:`-pinned values. SDK generators emit these as typed binding constants so frontend / API / SDKs reference one source of truth instead of hardcoding magic numbers. A runtime `GET /api/uploads/limits` endpoint for dynamic discovery (per-tier / per-environment overrides) is a deferred follow-up.
  *
- * The version of the OpenAPI document: 2.191.0
+ * The version of the OpenAPI document: 2.194.0
  *
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

package/dist/openapi/models/AccountLimitsLimits.d.ts

@@ -2,7 +2,7 @@
  * GISL Compression API
  * REST API for the GISL (Give It Smaller) file compression and processing service.  **Architecture:** - Upload files to get a `file_id` - Create workflows referencing uploaded files with operations (compress, thumbnail, image_watermark, text_watermark, merge, archive, convert, custom_luma, audio_overlay, audio_watermark) - Poll status, stream SSE events, or receive webhook callbacks - Download results per operation output  **Response envelope:** All mutation and query endpoints return `{ success: true, data: {...} }` on success and `{ success: false, error: \"...\", details: [...] }` on failure. Exceptions: `GET /api/operations/schema` returns raw JSON (per-tier private caching with ETag revalidation per ADR-0002 + I3), health probes return flat objects, and `POST /api/contact` returns 204 with no body.  **Availability metadata.** This spec uses the `x-availability` vendor extension as **decorative documentation only**. Per [ADR-0001](../docs/decisions/0001-contract-first-availability.md) §1.5, the runtime endpoint `GET /api/operations/schema` (ticket I3) is the authoritative source; the sidecar `availability.json` (ticket I3b) is the authoritative companion (generated, never hand-edited; CI cross-checks runtime ⇄ sidecar). SDKs MUST NOT depend on `x-availability` reaching generated code — code-generators that surface vendor extensions may emit it as documentation, but consumers read availability from the runtime endpoint, not from the generated bindings.  The 5-value vocabulary (`stable | beta | experimental | planned | deprecated`) is defined in the `AvailabilityValue` schema. See `schemas/FORMAT.md` §Availability Taxonomy for the operational rules (parser obligation: absent = stable; per-enum-value granularity is the `per_value_availability` primitive landed via ticket I17).  **Localisation (per ticket [I26](https://trello.com/c/rcnqwgI4)).**  Error responses + paused/blocked workflow statuses carry a localised human-readable `message` alongside a stable, never-localised `message_key`. Machine-readable fields (`error`, enum values, status codes) stay canonical English.  - **Currently committed locales:** `en-GB` only (per ticket   [`4GKyuYo6`](https://trello.com/c/4GKyuYo6)). The I26 carrier   shape (`Accept-Language` + `Content-Language` + `Vary` headers +   `locale` envelope field + `message_key` + `message_params`) is   stable and exercised; the **catalog** of translated `message`   strings is en-GB-only at runtime today. Additional locales (e.g.   `pt-PT`) will be advertised by name when their catalogs ship —   the request/response carrier shape does NOT change when a new   locale lands. Treat unrequested locales as \"machine-code +   `message_key` path is committed; localised `message` prose is   not\" until this prose enumerates them by name. - **Request:** `Accept-Language` header per RFC 9110 §12.5.4 (q-value   negotiation supported). The server selects the best-match locale   from its supported list; falls back to `en-GB` when no match —   which, until additional catalogs land, is every non-`en-GB`   `Accept-Language`. - **Response:** `Content-Language: <locale>` echo on every localised   response; `Vary: Accept-Language` on every response (CDN/cache   correctness — different `Accept-Language` requests produce   different responses). `Vary` is emitted unconditionally so the   header contract does not flip when a second locale ships. - **Fallback locale:** `en-GB` (also the canonical locale for   `message_key` translations and English `message` prose). - **SDK guidance:** switch on `error` (machine code) for typed   error branches; surface `message_key` to client-side i18n   catalogs (SDK companion work tracked at X19, cross-repo);   display `message` for end-user UI; **never parse `message` for   control flow** — it changes per locale.  Carrier shape lives on `ErrorEnvelope` (envelope-level optional `message_key` + `message` + `locale` + `message_params`) and `ValidationErrorEnvelope` (also per-`details[]` entry). Existing 402 / 403 / 422 envelopes (`BalanceExhaustedResponse`, `FeatureNotAvailableResponse`, `FeatureTierRestrictedResponse`, `WorkflowPausedDetail`) inherit the convention.  **Upload thresholds (per tickets [u0ar7Yye](https://trello.com/c/u0ar7Yye) + [58nBQLWQ](https://trello.com/c/58nBQLWQ)).** Canonical upload constants (single-shot cap, multipart chunk size, multipart concurrency default, multipart first-chunk size) live on the `UploadThresholds` schema with `const:`-pinned values. SDK generators emit these as typed binding constants so frontend / API / SDKs reference one source of truth instead of hardcoding magic numbers. A runtime `GET /api/uploads/limits` endpoint for dynamic discovery (per-tier / per-environment overrides) is a deferred follow-up.
  *
- * The version of the OpenAPI document: 2.191.0
+ * The version of the OpenAPI document: 2.194.0
  *
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

package/dist/openapi/models/AccountLimitsLimits.js

@@ -4,7 +4,7 @@
  * GISL Compression API
  * REST API for the GISL (Give It Smaller) file compression and processing service.  **Architecture:** - Upload files to get a `file_id` - Create workflows referencing uploaded files with operations (compress, thumbnail, image_watermark, text_watermark, merge, archive, convert, custom_luma, audio_overlay, audio_watermark) - Poll status, stream SSE events, or receive webhook callbacks - Download results per operation output  **Response envelope:** All mutation and query endpoints return `{ success: true, data: {...} }` on success and `{ success: false, error: \"...\", details: [...] }` on failure. Exceptions: `GET /api/operations/schema` returns raw JSON (per-tier private caching with ETag revalidation per ADR-0002 + I3), health probes return flat objects, and `POST /api/contact` returns 204 with no body.  **Availability metadata.** This spec uses the `x-availability` vendor extension as **decorative documentation only**. Per [ADR-0001](../docs/decisions/0001-contract-first-availability.md) §1.5, the runtime endpoint `GET /api/operations/schema` (ticket I3) is the authoritative source; the sidecar `availability.json` (ticket I3b) is the authoritative companion (generated, never hand-edited; CI cross-checks runtime ⇄ sidecar). SDKs MUST NOT depend on `x-availability` reaching generated code — code-generators that surface vendor extensions may emit it as documentation, but consumers read availability from the runtime endpoint, not from the generated bindings.  The 5-value vocabulary (`stable | beta | experimental | planned | deprecated`) is defined in the `AvailabilityValue` schema. See `schemas/FORMAT.md` §Availability Taxonomy for the operational rules (parser obligation: absent = stable; per-enum-value granularity is the `per_value_availability` primitive landed via ticket I17).  **Localisation (per ticket [I26](https://trello.com/c/rcnqwgI4)).**  Error responses + paused/blocked workflow statuses carry a localised human-readable `message` alongside a stable, never-localised `message_key`. Machine-readable fields (`error`, enum values, status codes) stay canonical English.  - **Currently committed locales:** `en-GB` only (per ticket   [`4GKyuYo6`](https://trello.com/c/4GKyuYo6)). The I26 carrier   shape (`Accept-Language` + `Content-Language` + `Vary` headers +   `locale` envelope field + `message_key` + `message_params`) is   stable and exercised; the **catalog** of translated `message`   strings is en-GB-only at runtime today. Additional locales (e.g.   `pt-PT`) will be advertised by name when their catalogs ship —   the request/response carrier shape does NOT change when a new   locale lands. Treat unrequested locales as \"machine-code +   `message_key` path is committed; localised `message` prose is   not\" until this prose enumerates them by name. - **Request:** `Accept-Language` header per RFC 9110 §12.5.4 (q-value   negotiation supported). The server selects the best-match locale   from its supported list; falls back to `en-GB` when no match —   which, until additional catalogs land, is every non-`en-GB`   `Accept-Language`. - **Response:** `Content-Language: <locale>` echo on every localised   response; `Vary: Accept-Language` on every response (CDN/cache   correctness — different `Accept-Language` requests produce   different responses). `Vary` is emitted unconditionally so the   header contract does not flip when a second locale ships. - **Fallback locale:** `en-GB` (also the canonical locale for   `message_key` translations and English `message` prose). - **SDK guidance:** switch on `error` (machine code) for typed   error branches; surface `message_key` to client-side i18n   catalogs (SDK companion work tracked at X19, cross-repo);   display `message` for end-user UI; **never parse `message` for   control flow** — it changes per locale.  Carrier shape lives on `ErrorEnvelope` (envelope-level optional `message_key` + `message` + `locale` + `message_params`) and `ValidationErrorEnvelope` (also per-`details[]` entry). Existing 402 / 403 / 422 envelopes (`BalanceExhaustedResponse`, `FeatureNotAvailableResponse`, `FeatureTierRestrictedResponse`, `WorkflowPausedDetail`) inherit the convention.  **Upload thresholds (per tickets [u0ar7Yye](https://trello.com/c/u0ar7Yye) + [58nBQLWQ](https://trello.com/c/58nBQLWQ)).** Canonical upload constants (single-shot cap, multipart chunk size, multipart concurrency default, multipart first-chunk size) live on the `UploadThresholds` schema with `const:`-pinned values. SDK generators emit these as typed binding constants so frontend / API / SDKs reference one source of truth instead of hardcoding magic numbers. A runtime `GET /api/uploads/limits` endpoint for dynamic discovery (per-tier / per-environment overrides) is a deferred follow-up.
  *
- * The version of the OpenAPI document: 2.191.0
+ * The version of the OpenAPI document: 2.194.0
  *
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

package/dist/openapi/models/AccountLimitsSuccessEnvelope.d.ts

@@ -2,7 +2,7 @@
  * GISL Compression API
  * REST API for the GISL (Give It Smaller) file compression and processing service.  **Architecture:** - Upload files to get a `file_id` - Create workflows referencing uploaded files with operations (compress, thumbnail, image_watermark, text_watermark, merge, archive, convert, custom_luma, audio_overlay, audio_watermark) - Poll status, stream SSE events, or receive webhook callbacks - Download results per operation output  **Response envelope:** All mutation and query endpoints return `{ success: true, data: {...} }` on success and `{ success: false, error: \"...\", details: [...] }` on failure. Exceptions: `GET /api/operations/schema` returns raw JSON (per-tier private caching with ETag revalidation per ADR-0002 + I3), health probes return flat objects, and `POST /api/contact` returns 204 with no body.  **Availability metadata.** This spec uses the `x-availability` vendor extension as **decorative documentation only**. Per [ADR-0001](../docs/decisions/0001-contract-first-availability.md) §1.5, the runtime endpoint `GET /api/operations/schema` (ticket I3) is the authoritative source; the sidecar `availability.json` (ticket I3b) is the authoritative companion (generated, never hand-edited; CI cross-checks runtime ⇄ sidecar). SDKs MUST NOT depend on `x-availability` reaching generated code — code-generators that surface vendor extensions may emit it as documentation, but consumers read availability from the runtime endpoint, not from the generated bindings.  The 5-value vocabulary (`stable | beta | experimental | planned | deprecated`) is defined in the `AvailabilityValue` schema. See `schemas/FORMAT.md` §Availability Taxonomy for the operational rules (parser obligation: absent = stable; per-enum-value granularity is the `per_value_availability` primitive landed via ticket I17).  **Localisation (per ticket [I26](https://trello.com/c/rcnqwgI4)).**  Error responses + paused/blocked workflow statuses carry a localised human-readable `message` alongside a stable, never-localised `message_key`. Machine-readable fields (`error`, enum values, status codes) stay canonical English.  - **Currently committed locales:** `en-GB` only (per ticket   [`4GKyuYo6`](https://trello.com/c/4GKyuYo6)). The I26 carrier   shape (`Accept-Language` + `Content-Language` + `Vary` headers +   `locale` envelope field + `message_key` + `message_params`) is   stable and exercised; the **catalog** of translated `message`   strings is en-GB-only at runtime today. Additional locales (e.g.   `pt-PT`) will be advertised by name when their catalogs ship —   the request/response carrier shape does NOT change when a new   locale lands. Treat unrequested locales as \"machine-code +   `message_key` path is committed; localised `message` prose is   not\" until this prose enumerates them by name. - **Request:** `Accept-Language` header per RFC 9110 §12.5.4 (q-value   negotiation supported). The server selects the best-match locale   from its supported list; falls back to `en-GB` when no match —   which, until additional catalogs land, is every non-`en-GB`   `Accept-Language`. - **Response:** `Content-Language: <locale>` echo on every localised   response; `Vary: Accept-Language` on every response (CDN/cache   correctness — different `Accept-Language` requests produce   different responses). `Vary` is emitted unconditionally so the   header contract does not flip when a second locale ships. - **Fallback locale:** `en-GB` (also the canonical locale for   `message_key` translations and English `message` prose). - **SDK guidance:** switch on `error` (machine code) for typed   error branches; surface `message_key` to client-side i18n   catalogs (SDK companion work tracked at X19, cross-repo);   display `message` for end-user UI; **never parse `message` for   control flow** — it changes per locale.  Carrier shape lives on `ErrorEnvelope` (envelope-level optional `message_key` + `message` + `locale` + `message_params`) and `ValidationErrorEnvelope` (also per-`details[]` entry). Existing 402 / 403 / 422 envelopes (`BalanceExhaustedResponse`, `FeatureNotAvailableResponse`, `FeatureTierRestrictedResponse`, `WorkflowPausedDetail`) inherit the convention.  **Upload thresholds (per tickets [u0ar7Yye](https://trello.com/c/u0ar7Yye) + [58nBQLWQ](https://trello.com/c/58nBQLWQ)).** Canonical upload constants (single-shot cap, multipart chunk size, multipart concurrency default, multipart first-chunk size) live on the `UploadThresholds` schema with `const:`-pinned values. SDK generators emit these as typed binding constants so frontend / API / SDKs reference one source of truth instead of hardcoding magic numbers. A runtime `GET /api/uploads/limits` endpoint for dynamic discovery (per-tier / per-environment overrides) is a deferred follow-up.
  *
- * The version of the OpenAPI document: 2.191.0
+ * The version of the OpenAPI document: 2.194.0
  *
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

package/dist/openapi/models/AccountLimitsSuccessEnvelope.js

@@ -4,7 +4,7 @@
  * GISL Compression API
  * REST API for the GISL (Give It Smaller) file compression and processing service.  **Architecture:** - Upload files to get a `file_id` - Create workflows referencing uploaded files with operations (compress, thumbnail, image_watermark, text_watermark, merge, archive, convert, custom_luma, audio_overlay, audio_watermark) - Poll status, stream SSE events, or receive webhook callbacks - Download results per operation output  **Response envelope:** All mutation and query endpoints return `{ success: true, data: {...} }` on success and `{ success: false, error: \"...\", details: [...] }` on failure. Exceptions: `GET /api/operations/schema` returns raw JSON (per-tier private caching with ETag revalidation per ADR-0002 + I3), health probes return flat objects, and `POST /api/contact` returns 204 with no body.  **Availability metadata.** This spec uses the `x-availability` vendor extension as **decorative documentation only**. Per [ADR-0001](../docs/decisions/0001-contract-first-availability.md) §1.5, the runtime endpoint `GET /api/operations/schema` (ticket I3) is the authoritative source; the sidecar `availability.json` (ticket I3b) is the authoritative companion (generated, never hand-edited; CI cross-checks runtime ⇄ sidecar). SDKs MUST NOT depend on `x-availability` reaching generated code — code-generators that surface vendor extensions may emit it as documentation, but consumers read availability from the runtime endpoint, not from the generated bindings.  The 5-value vocabulary (`stable | beta | experimental | planned | deprecated`) is defined in the `AvailabilityValue` schema. See `schemas/FORMAT.md` §Availability Taxonomy for the operational rules (parser obligation: absent = stable; per-enum-value granularity is the `per_value_availability` primitive landed via ticket I17).  **Localisation (per ticket [I26](https://trello.com/c/rcnqwgI4)).**  Error responses + paused/blocked workflow statuses carry a localised human-readable `message` alongside a stable, never-localised `message_key`. Machine-readable fields (`error`, enum values, status codes) stay canonical English.  - **Currently committed locales:** `en-GB` only (per ticket   [`4GKyuYo6`](https://trello.com/c/4GKyuYo6)). The I26 carrier   shape (`Accept-Language` + `Content-Language` + `Vary` headers +   `locale` envelope field + `message_key` + `message_params`) is   stable and exercised; the **catalog** of translated `message`   strings is en-GB-only at runtime today. Additional locales (e.g.   `pt-PT`) will be advertised by name when their catalogs ship —   the request/response carrier shape does NOT change when a new   locale lands. Treat unrequested locales as \"machine-code +   `message_key` path is committed; localised `message` prose is   not\" until this prose enumerates them by name. - **Request:** `Accept-Language` header per RFC 9110 §12.5.4 (q-value   negotiation supported). The server selects the best-match locale   from its supported list; falls back to `en-GB` when no match —   which, until additional catalogs land, is every non-`en-GB`   `Accept-Language`. - **Response:** `Content-Language: <locale>` echo on every localised   response; `Vary: Accept-Language` on every response (CDN/cache   correctness — different `Accept-Language` requests produce   different responses). `Vary` is emitted unconditionally so the   header contract does not flip when a second locale ships. - **Fallback locale:** `en-GB` (also the canonical locale for   `message_key` translations and English `message` prose). - **SDK guidance:** switch on `error` (machine code) for typed   error branches; surface `message_key` to client-side i18n   catalogs (SDK companion work tracked at X19, cross-repo);   display `message` for end-user UI; **never parse `message` for   control flow** — it changes per locale.  Carrier shape lives on `ErrorEnvelope` (envelope-level optional `message_key` + `message` + `locale` + `message_params`) and `ValidationErrorEnvelope` (also per-`details[]` entry). Existing 402 / 403 / 422 envelopes (`BalanceExhaustedResponse`, `FeatureNotAvailableResponse`, `FeatureTierRestrictedResponse`, `WorkflowPausedDetail`) inherit the convention.  **Upload thresholds (per tickets [u0ar7Yye](https://trello.com/c/u0ar7Yye) + [58nBQLWQ](https://trello.com/c/58nBQLWQ)).** Canonical upload constants (single-shot cap, multipart chunk size, multipart concurrency default, multipart first-chunk size) live on the `UploadThresholds` schema with `const:`-pinned values. SDK generators emit these as typed binding constants so frontend / API / SDKs reference one source of truth instead of hardcoding magic numbers. A runtime `GET /api/uploads/limits` endpoint for dynamic discovery (per-tier / per-environment overrides) is a deferred follow-up.
  *
- * The version of the OpenAPI document: 2.191.0
+ * The version of the OpenAPI document: 2.194.0
  *
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).