/*! Pixonaut SDK type declarations. Licensed under the MIT licence: see LICENSE-MIT. */
// Generated from apps/api/openapi.json by apps/api/scripts/generate-openapi.ts;
// do not edit. Regenerate: pnpm --filter @pixonaut/api gen:openapi
// Excluded from biome: its `check --write` on commit would reformat this
// file, and `--check` would then find it stale.

export interface paths {
    "/a/{token}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Fetch a print's artwork
         * @description The link a printshop is handed with an order, or the `fileUrl` a read of a completed print answers with. The token in the path is signed by the api and expires; no key is needed. Opening a read's link is a get of the print's files by its reader: the first counts as an order, and is refused as the print's own file route refuses one (`plan_limit_reached`, `order_balance_empty`, or `forbidden` for a reader without `orders:create`).
         */
        get: operations["prints.artwork.get"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/d/{token}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Fetch a print's file or ticket by delivery link
         * @description The links a custom printshop's delivery step hands the shop. The token in the path is signed by the api and expires; no key is needed. It names the print, the order it was made for, and whether it serves the print's file or that order's job ticket, which is read through the order.
         */
        get: operations["prints.deliveryFile.get"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/f/{file}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Fetch a font file
         * @description A font family's file by its content hash: a TTF for a renderer, a WOFF2 for a browser. Any cache may keep it for good, since the bytes at a hash never change. A TTF asked for with `text` is cut down to the glyphs those characters reach, every layout feature kept, so a renderer draws text made only of them as the whole face draws it; a `text` of more than 1000 distinct characters is served the whole face.
         */
        get: operations["fonts.files.get"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/i/{token}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Fetch a catalogue image
         * @description A library picture's preview, a blank mockup's photo, the image an option value is drawn as, a photo of a view of several placements, a view's or region's mask, or a published template's preview, through the link a read of blanks, templates or assets answered with (`thumbnailUrl`, `previewUrl`, an asset's `pictureUrl`, a showcase's `previewUrl`, a mockup's `mount.url`, an image appearance's `url`, a view's photo `url` or region `maskUrl`). The token in the path is signed by the api; no key is needed, so an image element can load it. A thumbnail, preview or picture link expires within two hours and only the caller's browser may cache it. A `mount.url`, an appearance's `url`, a view's photo `url` or a `maskUrl` stays valid for at least 30 days and at most 60, and any cache may keep it until then; it stops opening once the mockup's photo is replaced. A link to a mockup the blank no longer has, or to a version no longer published, does not open; a showcase's link naming a set the version does not hold is 404 `showcase_not_found`.
         */
        get: operations["catalogueImages.get"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/l/{token}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Fetch the logo a hosted page shows
         * @description The image a tenant's hosted pages show as its logo, through the link their share link's page is answered with. The token in the path is signed by the api and expires within two hours; no key is needed. A link to a logo the tenant has since replaced or cleared no longer opens. `width` serves it no larger than the box it is drawn in.
         */
        get: operations["logos.get"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/m/{id}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Fetch a published library asset
         * @description The preview of a library asset its tenant made public, such as a product photo a template shows. No key is needed, and shared caches may keep it, for up to 24 hours after the asset is made private or deleted.
         */
        get: operations["assets.published.get"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/p/{token}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Fetch a proof image
         * @description The link `POST /v1/proofs` answers with, for showing a customer what they are approving. The token in the path is signed by the api and expires; no key is needed.
         */
        get: operations["proofs.image.get"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/t/{id}/mockup.png": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Render a template on a product photo
         * @description The published template `id` (`baseId@version`) drawn into the print area a blank placement's mockup photo marks, as a PNG a storefront shows. A draft, an unknown blank, placement or mockup, and a mockup whose photo is gone are all 404, so the route says nothing about which of them is missing. `size` caps the long edge in pixels. `showcase` draws one of the template's showcases in place of its defaults, cached as the defaults are; an id the template holds no showcase under is 404 `showcase_not_found`. Naming neither `mockupId` nor `viewId` draws on the placement's first view. A studio member reads it with their session, in the workspace the `x-tenant-id` header names, holding `templates:read`.
         */
        get: operations["templates.mockup.get"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/t/{id}/preview.png": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Render a template's preview image
         * @description The published template drawn with its own default values and clipped to its die-cut shape, as a PNG a storefront shows as a thumbnail. `id` is `baseId@version`. Every answer carries an ETag, and a matching `if-none-match` answers 304. An image read with a key is served `no-cache`: its URL names no workspace, and a text naming dynamic values, such as `{date.year}`, draws anew as days pass. A studio thumbnail of a published version never changes and is served `immutable`. `size` caps the long edge in pixels; `bleed=1` draws the unclipped full-bleed reference instead; its extent is the tenant's default bleed, which can change, so it is served `no-cache` and revalidated with its ETag. A key reads published versions only: any other id is 404. `showcase` draws one of the template's showcases in place of its defaults, cached and revalidated as the defaults are; an id the template holds no showcase under is 404 `showcase_not_found`. The image carries no "Powered by Pixonaut" mark on any plan: a shop shows it as its own product image.
         */
        get: operations["templates.preview.get"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/u/{token}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        /**
         * Upload a file's bytes
         * @description The `uploadUrl` `POST /v1/assets` answered with. The body is the file itself, exactly the mime and the number of bytes declared there; no key is needed, since the signed token in the path is the credential. A small image is accepted with a `warning` (and `warningKey`, `warningParams` for translation) rather than refused.
         */
        put: operations["assets.upload"];
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/admin/sessions/{id}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Inspect a customer session's uploads and proofs
         * @description Lists every upload and proof one designer session left behind, with when each was made and when each proof expires. `retained` is 1 for one that a committed design or a published template uses, which is kept for as long as that use lasts and which a wipe does not delete, and 0 for one that expires on its own. For support, and for checking what a wipe kept; a storefront does not need it.
         */
        get: operations["customerSessions.get"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/api-keys": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List the tenant's API keys
         * @description Newest first. Metadata only: a key itself is shown once, when it is created. Each key names the member who created it (`createdBy`, with their name as it is now), or null when no member did: a key a secret key created, or one the deployment configures.
         */
        get: operations["apiKeys.list"];
        put?: never;
        /**
         * Create an API key
         * @description Answers with the key itself, which is never shown again. A publishable key is refused from any origin outside its `allowedOrigins`. An MCP key is created by a member, for their own AI assistant, and acts as them; in a sandbox it acts on the sandbox alone.
         */
        post: operations["apiKeys.create"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/api-keys/{id}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        post?: never;
        /**
         * Revoke an API key
         * @description A key from the deployment's configuration (`managed`) cannot be revoked here, nor a key a connected store was given (`connectionId`): disconnecting the store revokes it with the rest of what the store holds.
         */
        delete: operations["apiKeys.delete"];
        options?: never;
        head?: never;
        /**
         * Rename an API key or change its origins
         * @description Takes what creating that kind of key takes: a secret or integration key, `api-keys:manage`; an MCP key, being the member who created it. A key from the deployment's configuration (`managed`) is not changed here, nor a key a connected store was given, except to rename its integration key: a store's site is changed by connecting it again. Later audit entries name a renamed key by its new name; earlier ones keep the name it had when it acted.
         */
        patch: operations["apiKeys.update"];
        trace?: never;
    };
    "/v1/asset-categories": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List asset categories
         * @description Every category, by name, with how many finished library assets it holds. With `q`, `page` or `pageSize`, a page of the categories whose name holds `q`, with how many match.
         */
        get: operations["assetCategories.list"];
        put?: never;
        /** Create an asset category */
        post: operations["assetCategories.create"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/asset-categories/{id}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        post?: never;
        /**
         * Delete an asset category
         * @description Its assets stay, with no category.
         */
        delete: operations["assetCategories.delete"];
        options?: never;
        head?: never;
        /** Rename an asset category */
        patch: operations["assetCategories.update"];
        trace?: never;
    };
    "/v1/asset-duplicate/{sha256hex}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Check whether the tenant already stores a file
         * @description Asks by the file's SHA-256, in lowercase hex, before uploading it. Advisory: uploading a duplicate is allowed, and counts against the quota again.
         */
        get: operations["assets.checkDuplicate"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/asset-filters": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List the values the asset listing can filter on
         * @description The sessions and templates assets were uploaded for, most recent first, and the categories and tags, by name. Each list is capped, so a large tenant's is not complete.
         */
        get: operations["assetFilters.list"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/asset-tags": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List asset tags
         * @description Every tag the tenant's assets carry, each with how many assets carry it, the most used first, then by name. With `q`, `page` or `pageSize`, a page of the tags that hold `q`, in the same order, and how many tags match.
         */
        get: operations["assetTags.list"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/assets": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List assets
         * @description The tenant's finished assets of every kind, newest first (or with `sort=most-used`, the ones the most of the tenant's drafts use first, then by name), a page at a time. An empty filter is the same as leaving it out. `role=picture` lists the pictures and `role=blank-photo` the blank photos; absent, both. `category=none` lists the assets in no category. `q` matches a name anywhere, or the start of an asset or session id. `retention=retained` lists what nothing will delete, and `auto-delete` everything else. `ids=a,b` narrows to the named assets; an id this tenant does not hold is left out. Each asset says what it was upscaled from; `upscaleSources=hide` lists an upscale in place of the picture it was made from, when the upscale is listed too.
         */
        get: operations["assets.list"];
        put?: never;
        /**
         * Start an upload
         * @description Declares the file about to be uploaded and answers with an `uploadUrl` to `PUT` its bytes to, good once and for 10 minutes. A publishable key's upload is always a design upload, deleted when the tenant's retention runs out unless an order holds it. A secret key's is a library asset unless `kind` is `design-upload`; `visibility: "public"` publishes a library asset at `/m/{id}`.
         */
        post: operations["assets.create"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/assets/bulk": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Retain or delete assets in bulk
         * @description Answers every id on its own, in `results`, so one refusal does not fail the rest. `retain` keeps design uploads from being deleted when the tenant's retention runs out; any other id answers `not_found`. `delete` deletes assets of either kind, refusing each one as `DELETE /v1/assets/{id}` would, and a design upload an order holds as `order_referenced`.
         */
        post: operations["assets.bulkUpdate"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/assets/import": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Import a picture into the library
         * @description Saves a picture to the library in one call, from a public `url` this server fetches or as base64 `data` (up to 655360 bytes), with its name, tags and category. It is held to an upload's limits: its type read from its bytes, its size, its pixels and the tenant's storage quota.
         */
        post: operations["assets.import"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/assets/{id}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Read an asset
         * @description One finished asset of any kind. Its bytes are at `/v1/assets/{id}/content` and `/v1/assets/{id}/original`.
         */
        get: operations["assets.get"];
        put?: never;
        post?: never;
        /**
         * Delete a library asset
         * @description Refused while something still names the asset: a template version or draft (`template_referenced`, with where), a blank's photo (`blank_referenced`), or the tenant's logo (`logo_referenced`, chosen in its settings; choose another first). `delete_failed` means another write held the tenant's assets for too long; nothing changed, and the request can be sent again. A design upload is deleted through `POST /v1/assets/bulk`.
         */
        delete: operations["assets.delete"];
        options?: never;
        head?: never;
        /**
         * Update a library asset
         * @description Sets the fields the body names and leaves the rest. `tags` replaces the asset's tags with this set, each normalised to lowercase with spaces as dashes; `categoryId: null` clears the category. `role` moves the asset between a picture and a blank photo; a blank photo is in no category, so becoming one clears it and `blank_photo_uncategorised` refuses one a category.
         */
        patch: operations["assets.update"];
        trace?: never;
    };
    "/v1/assets/{id}/content": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Fetch an asset's preview
         * @description The asset's preview when it has one, else the file as stored: what a thumbnail or a canvas shows. A publishable key reads a customer's upload only with the designer session header it was uploaded with, and a library asset only once it is public or shown or offered by a published version of a template; anything else answers 404, as a missing asset does. `width` serves it no larger than the box it is drawn in; each resize asked for with a key or through a link spends the tenant's render budget, and is refused `rate_limited` once it is spent. The etag names the stored bytes and the size asked for, so `If-None-Match` answers 304 for as long as a cached copy is good.
         */
        get: operations["assets.content.get"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/assets/{id}/cut-out": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * How a customer's upload's cut-out stands
         * @description How the cut-out asked of this upload (`POST /v1/assets/{id}/cut-out`) stands: running, done with the cut-out to put in the upload's place, or failed, and whether it may be asked again.
         */
        get: operations["assets.cutOutStatus"];
        put?: never;
        /**
         * Cut out a customer's upload
         * @description Cuts a customer's upload into a picture that cuts out (`cutOut` on the picture's constraints) out of its background, in the background: answers 202 at once, and `GET /v1/assets/{id}/cut-out` says how it stands. Done, the cut-out is a new upload for the same picture, to put in the upload's place; the upload is left as it was, so the customer may always go on with it uncut. Paid from the tenant's credits once the cut-out is kept; one that fails charges nothing and may be asked once more (`retryable`). Asked again while it runs or once it is done, it answers how it stands (200) and charges nothing.
         */
        post: operations["assets.cutOut"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/assets/{id}/improve-resolution": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Improve a customer's upload before the proof
         * @description Upscales a customer's upload that is below its picture's upscale density (`upscale.belowDpi` on the picture's constraints, else the minimum print resolution) at the size it was uploaded for, to the size at which it reaches the picture's target density (`upscale.toDpi`, else that density), into a new design upload for the same layer; the upload is left as it was. Offered by the upload's own answer (`improveResolution`) only where the picture it was uploaded into offers an upscale, the tenant's credits cover it, the upload is short of the target too, and the shortfall is within one upscale. Takes no size: the upload decides it. Each upload is improved at most once: asked again once delivered, it answers the same improved upload (200) and charges nothing. Paid from the tenant's credits when delivered.
         */
        post: operations["assets.improveResolution"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/assets/{id}/original": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Fetch an asset's file
         * @description The file as stored, at full resolution. An upload in a format the api converts is stored, and so served, as PNG. Not for a publishable key: a storefront only ever shows the preview.
         */
        get: operations["assets.original.get"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/assets/{id}/round-shapes": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Find the round shapes in a picture
         * @description The circles and rings a picture holds, such as a photo frame or a badge, read from its edges: each one's centre and radius as fractions of the picture, and, given an artwork's `ratio`, where it lands with the picture as that artwork's background. A shape partly hidden still counts when most of its edge shows; an oval or a square does not.
         */
        get: operations["assets.roundShapes.get"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/assets/{id}/usage": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Where an asset is used
         * @description Every use of a finished asset, grouped, and not paged: the templates, blank photos and workspace logo a delete is refused over, and the orders and committed designs that keep a customer's picture. A member sees the orders only with `orders:read` and the designs only with `designs:read`; `withheld` counts what was left out. A delete still answers its own 409 when a use lands after this read.
         */
        get: operations["assets.usage.get"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/automations": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List the workspace's automations
         * @description A page of the workspace's automations by name, each with where it stands and what its firings come to, and how many match in all.
         */
        get: operations["automations.list"];
        put?: never;
        /**
         * Make an automation
         * @description A disabled automation at version 1, authored by the member who makes it. Unnamed, it is called "Automation N". Left out, it has no trigger, and its `sources` are every designer link and key, those to come too, and no store. One made with a secret key runs as the workspace, and only an admin may make one that does otherwise.
         */
        post: operations["automations.create"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/automations/check": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Check a draft
         * @description What saving this draft would refuse and warn of, and for each step that acts at a printshop, what it can do at every printshop it can reach: yes, no and why, or only while a rule holds. Nothing is saved.
         */
        post: operations["automations.check"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/automations/placeholders": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List the placeholders an automation may write
         * @description Every placeholder an automation's texts may name, by namespace, with what it holds, whether it can be empty, and whether it is personal data, which only an action bound for the order's own printshop may write. A text writes `{order.id}`, `{{` for a brace of its own, `{order.reference ?? "none"}` for a fallback, and `{actions.<step>.id}` for what an earlier step made. A save refuses a name not listed.
         */
        get: operations["automations.placeholders"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/automations/test-run": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Test an automation on a past event
         * @description What it would have done: each condition with the values compared, each step blocked and why or run, its placeholders rendered and the limits a spend would count against. A wait does not wait. Nothing is moved, sent or stored, and a test run is never a firing.
         */
        post: operations["automations.testRun"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/automations/test-run/events": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Find events to test an automation on
         * @description The newest 20 events of its trigger in its sources, or one older one by its id. Nothing is run.
         */
        post: operations["automations.testRunEvents"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/automations/{id}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Read an automation */
        get: operations["automations.get"];
        /**
         * Save an automation
         * @description The whole draft, stored as its next version. A save since `expectedUpdatedAt` is refused `automation_changed`. The saver becomes its author, unless it runs as the workspace; only an admin may save one that does, or set it to. An MCP key saves only a disabled one.
         */
        put: operations["automations.save"];
        post?: never;
        /**
         * Delete an automation
         * @description It is gone from every read, and its unfinished firings are cancelled. Its firings are kept for their 90 days.
         */
        delete: operations["automations.delete"];
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/automations/{id}/disable": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Disable an automation
         * @description It fires no more, and its waiting firings are cancelled: the answer says how many. The list's `firings.waiting` says it beforehand. One already disabled is answered as it is.
         */
        post: operations["automations.disable"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/automations/{id}/duplicate": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Duplicate an automation
         * @description A disabled copy at version 1, authored by the member who copies it. A copy of one that runs as the workspace does too, and only an admin may make it.
         */
        post: operations["automations.duplicate"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/automations/{id}/enable": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Enable an automation
         * @description It fires from now on: never on an event recorded before. One already enabled is answered as it is. One with no trigger is refused `automation_no_trigger`. With `expectedUpdatedAt`, one saved since is refused `automation_changed` and left disabled.
         */
        post: operations["automations.enable"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/automations/{id}/firings": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List an automation's firings
         * @description Newest first: each firing's state, what it acts on, the step it got to and why, when it started, its version and whose grants it ran with; with how many each status filter holds, the search applied.
         */
        get: operations["automations.firings"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/automations/{id}/firings/{firingId}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Read one of an automation's firings
         * @description Its event and the chain it belongs to, each step of its version with its state and reason, and what members did to it.
         */
        get: operations["automations.firing"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/automations/{id}/firings/{firingId}/cancel": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Cancel a waiting or paused firing
         * @description It stops where it is and does nothing more.
         */
        post: operations["automations.firings.cancel"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/automations/{id}/firings/{firingId}/resume": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Resume a paused firing
         * @description A firing paused at a spend limit takes its spend action once, past the limit. Its automation must be enabled.
         */
        post: operations["automations.firings.resume"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/automations/{id}/firings/{firingId}/retry": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Retry a failed firing
         * @description It runs again from its failed action, on the version it started on. A firing stopped for a chain too deep is not retried. Its automation must be enabled.
         */
        post: operations["automations.firings.retry"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/automations/{id}/past-events": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Apply an automation to past events
         * @description It fires once on each event of its trigger in the window that is in its scope and meets its conditions, at most 500 over at most 30 days. Its firings run under the spend limits: those past a limit pause.
         */
        post: operations["automations.applyToPastEvents"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/automations/{id}/past-events/preview": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Preview applying an automation to past events
         * @description How many events of its trigger a window holds (at most 500, over at most 30 days), and a test run on the newest. Nothing is fired.
         */
        post: operations["automations.pastEventsPreview"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/automations/{id}/versions": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List an automation's versions
         * @description Newest first: who saved each and when, what it changed from the version before, whether it is current, and how many firings are still on it. Versions are never edited or deleted.
         */
        get: operations["automations.versions"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/blanks": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List the tenant's blanks
         * @description A page of the tenant's blanks by name. `q` keeps the blanks whose name holds it, case aside; `hasPlacements=true` keeps the ones with a placement to print on; `printshop` keeps the ones that printshop connection makes; `category` the ones in that blank category. Each row carries its placements and views, its options and variant count, `optionsConfirmedAt`, its photo coverage and a `thumbnailUrl` of its first view photo. A deleted blank is left out; `deleted=only` lists the deleted ones instead, newest first, each with when and by whom it was deleted.
         */
        get: operations["blanks.list"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/blanks/{id}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Read a blank
         * @description One blank with its placements and variants. A deleted blank is read too, with when and by whom it was deleted, so an order placed on it can show it.
         */
        get: operations["blanks.get"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/blanks/{id}/mockups": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List a blank's placements, views and mockups
         * @description The placement and mockup ids a mockup render names, each placement's views with their labels, photo sizes and print rects, and each view's photos (the mockups) with the variants each shows, in stored order. The order is not an identifier: it changes when the blank is reordered in the studio, so persist the ids. A placement whose stored sizes are unusable is left out. Each placement carries the largest and default print box, whether a print covers its whole area, the bleed and safe area it prints with (its own, else the tenant's default) and its print method. Each mockup carries a `thumbnailUrl`, a link to its photo that opens with no key for an hour or two, and a `mount`: what a storefront passes to the designer as one of `mockups`, with a photo link that stays valid for at least 30 days. With `lang`, each view's label is the blank's for it in that language, else its own.
         */
        get: operations["blanks.mockups.list"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/blanks/{id}/placements/{placementId}/fitting-templates": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List the templates that fit a placement
         * @description Every one of the tenant's templates, with the verdict for its artwork at the size it would print at on this placement. It answers geometry, not whether the pairing is sold. `status` defaults to live templates; `q` keeps the templates whose name holds it, case aside. A placement without usable measurements is answered as not found. On a placement whose print area changes with an option, `sizes` names the option values each template can and can't print at.
         */
        get: operations["blanks.placements.fittingTemplates.list"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/blanks/{id}/placements/{placementId}/preview-tables": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Read the colour tables a placement draws with
         * @description The estimate and preview tables a design on the placement draws its colours through on screen, where the print goes through an output profile the workspace uploaded: the constraints read naming the placement says this path as `cmykPreviewTables` once they are made. Refused with `no_preview_tables` where the design is drawn through a bundled profile's (`cmykPreviewProfile`), or the tables are not made.
         */
        get: operations["blanks.previewTables.get"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/blanks/{id}/variants": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List a blank's variants
         * @description Every purchasable combination of the blank's options, such as Color × Size, in the blank's order, retired ones included. Each carries its `ref`, the id an order or render names it by; its options; whether it is retired, and why; and the views it has a photo in. A retired variant still resolves for the orders that name it, and a new order or render naming it is refused. A blank with no options has one variant, with none. With `lang`, every option, value and view is named as that language reads it, in each place it appears: the blank's name for it in that language, else its own.
         */
        get: operations["blanks.variants.list"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/blanks/{id}/views/{viewId}/mockup.png": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Render a view of a blank with its prints
         * @description The view's photo with a published template drawn in each of its regions, as a PNG a storefront shows: a sweater's front and both sleeves on one photo, a roll's window of its print. A region with no template shows its placement's fill colour, or the photo alone. An unknown blank, view or template, and a photo that is gone, are 404.
         */
        get: operations["blanks.views.mockup.get"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/connect": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Read this store's connection
         * @description Called with the store's own integration key. Answers where the store is connected as it is now: its name after a rename in the studio, the workspace and its environment, its webhook endpoint and its publishable key's origins. Answers the brand the store's hosted pages are drawn in, its own or else the workspace's default, and the workspace's brands it may choose from with `PATCH /v1/connect`. Also answers, read only, the workspace settings that change what the store's customers and merchant get, as the studio's settings show them now: whether a proof carries a watermark, the saved address new orders ship to, the print defaults and how long a customer upload is kept. A store connected to a sandbox reads the sandbox's. A member changes them in the studio.
         */
        get: operations["connectedStore.get"];
        put?: never;
        post?: never;
        /**
         * Disconnect this store
         * @description Called with the store's own integration key. Revokes the integration key, the publishable key and the webhook endpoint the store was given when it connected.
         */
        delete: operations["connectedStore.delete"];
        options?: never;
        head?: never;
        /**
         * Change this store's origins or brand
         * @description Called with the store's own integration key. `additionalOrigins` is for a store whose pages also run on other hosts of its own domain: its counterpart with or without `www.`, a checkout or a headless storefront. It sets the origins the publishable key takes besides the site's own, which then admit the designer with that key and may receive a designer link's `returnUrl`. An origin on any other domain is `400 invalid_origin`, naming it, and nothing changes; a member mints a publishable key for it in the studio. More origins than the limit is `400 too_many_origins`. Reconnecting starts again from the site's own origin. `brandId` sets the brand the store's hosted pages are drawn in: proof pages, correction links and designer links its key creates from then on, each keeping the brand it was created in. An id that is not one of the workspace's brands is `404 brand_not_found`, and nothing changes. A member may set it in the studio too; a brand a store is drawn in cannot be deleted.
         */
        patch: operations["connectedStore.update"];
        trace?: never;
    };
    "/v1/connect/member-link": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        post?: never;
        /**
         * Unlink a member from the store
         * @description Revokes the member key it is sent with. Its next use, here or anywhere, is refused `member_link_revoked`; the store's own connection and the member's other links are untouched.
         */
        delete: operations["memberLinks.delete"];
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/connect/token": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Exchange a connect code for store credentials
         * @description Called by the store's server with the code the studio sent its merchant back with, the PKCE verifier it made the challenge from, and the same `redirect_uri`. Answers, once, an integration key, a publishable key bound to the store's origin, a webhook endpoint registered at the store with its signing secret, and the member key of the member who approved. A code works once, for a minute: any attempt uses it, and every refusal is `invalid_grant`, after which the store connects again. Connecting a site that is already connected replaces its connection, revoking what it was given before. With `kind: "member_link"` and the store's integration key as the bearer, exchanges a member link's code for the approving member's member key instead; a code approved for another store or workspace is `invalid_grant`.
         */
        post: operations["connectedStore.exchangeCode"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/designs": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List the tenant's designs, newest first
         * @description `status` narrows the list to one status, `q` to designs whose template name, id or your own reference holds it, `template` to the designs of the template with that base id, `externalRef` to the designs holding your own reference, matched exactly, `standing` to the standing designs or to the rest, and `receivedFrom` and `receivedTo` to the designs received between them. `order=asc` lists the oldest first. `counts` says how many designs each status holds under the other filters. Rows carry no document and no fulfilment payload; read one design for those.
         */
        get: operations["designs.list"];
        put?: never;
        /**
         * Commit a design
         * @description Commits a customer's design, from a proof token (secret or integration key only) or from a template and its values. A printshop it names, or the partner a locked blank is made by, is kept on the design and is where its orders go unless an order names another; with none, an order goes to the blank's default printshop, else the tenant's, as they are when the order is made. A fulfilment payload lacking a key is refused 422 `missing_fulfilment_keys` against where the design would go now, short of the keys that printshop takes only once there is an order (Printful's `recipient`); each order checks every required key again against the printshop it goes to, and that check decides. A design holding a spot ink that may not print from its CMYK fallback is refused 422 `spot_plate_required` the same way, where that printshop takes no spot plates. A design committed from a template is fitted to and records the blank and placement it names, and a named placement that does not resolve is refused 422 `unknown_placement`; one committed from a proof token records the proof's. Only a secret or integration key may attach a fulfilment payload, an external reference or choose the printshop.
         */
        post: operations["designs.commit"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/designs/decisions": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Approve or reject several designs
         * @description Approves or rejects up to 200 designs, each as `POST /v1/designs/{id}/approve` or `/reject` decides it: the same grant, the same refusals, its own event and audit entry. Each design answers its own outcome, in the order the request named them; one refused leaves the others to be decided, so a 200 may hold refusals. `afterDays` schedules each approval, and `reason` is kept on each rejected design. Repeating a decision that already stands answers it again and records nothing more. Deleting several designs is one `DELETE /v1/designs/{id}` each.
         */
        post: operations["designs.decide"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/designs/layout": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Commit a design drawn on a blank's panel layout
         * @description Commits a design drawn across a blank's panel layout, so all-over art runs unbroken across the seams of the panels it is printed on. The template is resolved once, on the layout's canvas at the size the request names (`variant` or `variantRow`, as on `POST /v1/designs`), and the answer holds one design per placement the layout has a window for: its print is the canvas seen through that placement's windows, the size of the placement's print area at that size. Order them as the prints of one item. In place of a template and its values, a secret or integration key may send the `proofToken` of a layout's proof the customer approved (`POST /v1/proofs/layout`): its canvas is cut as approved, at the proof's blank, layout and size, and the token commits once. A proof of anything else is refused `not_layout_proof`. A layout the blank does not have is refused `unknown_layout`; one whose windows no longer fit the blank's print areas at that size, `layout_out_of_date`. Every design is resolved and checked before any is made; one refused after that leaves the others made. A secret key, an integration key with `designs:create`, or a member.
         */
        post: operations["designs.commitThroughLayout"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/designs/standing": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Find or create a standing design
         * @description Finds the workspace's standing design for a template version, blank, placement and print size, or makes it from the template version as its author left it: the workspace's own design for a fixed product, which is ordered any number of times without `reorder`, each order reusing the print of its current revision. One live standing design per template version, blank, placement and size: the same request again answers the same design, 200 with `created: false`, and two sent at once make one. Made, it answers 201 with `created: true`. A rejected or deleted standing design is not found, and the next request makes another. `blankId` and `placementId`, both or neither, and `widthMm` and `heightMm`, both or neither, as on `POST /v1/designs`: no size is the placement's default size, which finds the design naming that size made. On a blank whose print areas change with its size, `variant` or `variantRow` names the size it is for, as on `POST /v1/designs`, and one standing design is kept per size. A connected store finds only the standing designs its own keys made, and never the workspace's own. The version is read as a number, so `mug@04` finds the design `mug@4` made, and the answer spells it `mug@4`. A `key`, the store's own name for a product, keeps a standing design per product: one naming a key finds only the design that key made, from the same store. A `proofToken` from a correction link handed out with `adjustLayout` makes the design from that layout adjustment, as a standing design of its own that the same proof finds again, for a store to keep one product's row laid out by hand while the others follow the template; the design it was laid out from is not changed. A secret key, an integration key or a member holding `designs:create`; a publishable key or a link is refused `secret_key_required`. Nothing is approved unless `approve: true` asks.
         */
        post: operations["designs.findOrCreateStanding"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/designs/{id}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Read one design */
        get: operations["designs.get"];
        put?: never;
        post?: never;
        /**
         * Delete a design
         * @description Deletes a design that was never bought: one not approved and never printed, such as a design committed for a cart that was abandoned. It is gone from every list and read, its share links stop working, and its proof and pictures are released. No rejection is recorded; `design.deleted` is. Refused `design_approved` for an approved design and `design_printed` for one with a print, corrected since or not.
         */
        delete: operations["designs.delete"];
        options?: never;
        head?: never;
        /**
         * Correct a design that has not been ordered
         * @description Applies `values` on top of the design's document under the rules its template version sets, keeps the size it was committed at, and sends it back to awaiting approval: any approval, made or scheduled, is cleared, and nothing is printed or ordered until it is approved again. Renders a proof of the corrected document, which becomes the design's proof (`proofId`); a correction whose proof cannot be rendered is refused, and writes nothing. Or, with `proofToken` instead, makes a correction proof's document the design's next revision and that proof the design's proof, refused `proof_not_for_design` for a proof of another design, or of no design, `proof_adjusts_layout` for a layout adjustment's proof, which `POST /v1/designs/standing` takes, and `revision_changed` once the design has moved past the revision the proof was made from. Emits `design.edited`. A correction that leaves the document as it is writes nothing — not a revision, not a cleared approval, not an event — and answers `edited: false`. Refused once any print of the design has an order.
         */
        patch: operations["designs.update"];
        trace?: never;
    };
    "/v1/designs/{id}/approve": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Approve a committed design
         * @description Approves now, or after `afterDays` days when the tenant wants a window for the customer to change their mind. Safe to retry: approving now a design already approved at `expectedRevision` (or at any revision, when none is given) answers `approved` again and records nothing more; one rejected, or approved at another revision, is refused `not_committed`. Through a deciding proof page link, approves now only, must carry `expectedRevision` (else `bad_request`), and is refused `proof_outdated` unless the design's proof shows its current revision, which a design committed without a proof never has.
         */
        post: operations["designs.approve"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/designs/{id}/correction-links": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Hand out a correction link for a design
         * @description A share link that reopens this one design in the designer, for a store to let its customer correct it: the SDK's credential (`correctionLink`) on the store's own page, or, with a `returnUrl`, a hosted correction page that returns to the store. It works for 2 hours, from the store's pages and the hosted ones, for this design only. Approving in the designer makes a proof of the correction and writes nothing; `PATCH /v1/designs/{id}` with that proof's token makes it the design's next revision. Refused for a design that takes no correction. With `adjustLayout`, the link lays a standing design out instead, and its proofs make standing designs of their own (`POST /v1/designs/standing`).
         */
        post: operations["designs.correctionLinks.create"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/designs/{id}/correction-proofs": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Proof a correction of a design without making it
         * @description Applies `values` on top of the design as it is at `expectedRevision`, under the rules its template version sets and at the size it was committed at, and renders the result, exactly as `PATCH /v1/designs/{id}` would. Empty `values` proof the design as it is. Writes nothing to the design. Made in the customer session `x-pixonaut-session` names, if any, whose wipe deletes it until it is redeemed. The answer's `proofToken` is redeemed by `PATCH /v1/designs/{id}` with `{proofToken}`, which makes this document the design's next revision as long as the design is still at `expectedRevision`. Refused for a design that takes no correction. Through a correction link handed out with `adjustLayout`, the proof is a layout adjustment of a standing design, ordered or not: `values` may only move and scale its layers (`<layerId>.transform`, `xMm`, `yMm` and `scale`), each within the plate, and its token is taken by `POST /v1/designs/standing`, never by `PATCH`.
         */
        post: operations["designs.correctionProofs.create"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/designs/{id}/delivery": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Read a design's first-order delivery
         * @description A secret key, a studio member holding `orders:read`, or the design's address capture link. The delivery given for the design's first order, while the design is open; once it is ordered, the delivery its newest open order holds now — or, through an address capture link bound to one order, that order's, with `orderClosed` once it is closed — while that order's address can still change (`changeable`), else none; once it is erased or rejected, none.
         */
        get: operations["designs.delivery.get"];
        /**
         * Set a design's first-order delivery
         * @description A secret key, an integration key holding `orders:create`, a member holding `orders:update`, or the design's address capture link. Replaces any delivery given before. The design's first order takes it as its `recipient` and `shippingAddress` when its request names neither; an order whose request names either goes by the request alone, and this delivery is dropped. Once the design has an order, it changes the design's newest open order — or, through an address capture link bound to one order, that order alone — as `PATCH /v1/orders/{id}/delivery` does, by the customer, when that order's printshop takes address changes, and answers `orderId` and the order's `delivery`; otherwise it is refused `design_ordered`, and `order_closed` once a bound link's order has shipped, will not be made or its personal data was erased. Refused `design_erased` once its personal data was erased, and `design_rejected` once it is rejected. Never written to logs.
         */
        put: operations["designs.delivery.update"];
        post?: never;
        /**
         * Erase a design's first-order delivery
         * @description A secret key, or a connected store's integration key or a member holding `orders:update`, in the studio or through their MCP key. Erases the delivery given for the design's first order, on its customer's request; erasing none is answered the same. Once the design is ordered, the order holds it, and the order's own erasure applies.
         */
        delete: operations["designs.delivery.delete"];
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/designs/{id}/designer": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Open a design in the designer to correct it
         * @description The design's current document and revision, and its template version exactly as `GET /v1/templates/{id}` answers it, so the designer can show the design as it is and apply changes over it as `PATCH /v1/designs/{id}` will. Through a correction link handed out with `adjustLayout`, a standing design opens whether or not it was ordered, and its template version moves and scales every printed layer within the plate and offers nothing else, as its layout adjustment is judged; `not_standing` for any other design. Refused for a design that takes no correction, `design_doc_unreadable` for one whose document the current model cannot read, and `template_unreadable` for one whose template version cannot be read. An SDK names its release in `x-pixonaut-sdk-version`; a release whose renderer cannot draw the template version is refused `sdk_outdated`, naming the first release that can.
         */
        get: operations["designs.designer.get"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/designs/{id}/duplicate": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Duplicate a design
         * @description Makes a new design from this one, awaiting approval on its own, with the same template version, document, blank, printshop and fulfilment payload, and `duplicated_from` naming its source. Emits `design.duplicated`, not `design.committed`. The way to correct a design that has been ordered. Refused `design_erased` for a design whose personal data was erased.
         */
        post: operations["designs.duplicate"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/designs/{id}/erase-personal-data": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Erase a design's personal data
         * @description Erases what the design's customer put into it, whatever its status, approved and printed included: the text of every field they could fill, and every picture they uploaded, in every revision and proof of the design, the words of any request for changes, and the delivery they gave. The design stays as a record (its template, status, dates and prints), `personal_data_erased_at` says when, and nothing more is printed, ordered, corrected, duplicated or asked to change from it. The pictures and proofs are deleted within six hours. A print's files are kept while an order of it is still being made, and deleted within six hours once every order of it has shipped, failed or been cancelled. Not erased: the fulfilment payload, which is yours, designs duplicated from this one, and what a printshop was already sent. Emits `design.personal_data_erased`. Erasing a design already erased answers it unchanged and records nothing. A deleted design is erased too, and answered `204`.
         */
        post: operations["designs.erasePersonalData"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/designs/{id}/external-ref": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        /**
         * Replace a design's external reference
         * @description Replaces the reference the design was committed with, such as moving it from your cart line to the order line that bought it. Nothing else about the design changes: it stays approved, or awaiting approval, as it was. A secret key, or an integration key or a member holding `designs:update`.
         */
        put: operations["designs.externalRef.update"];
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/designs/{id}/mockup.png": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Render a design on a product photo
         * @description The design drawn into the print area of its blank's photo and blended with its shading, exactly as `GET /t/{id}/mockup.png` draws a template: what a store shows in its cart, order pages and emails once the customer has committed. The artwork is the design's newest revision with a proof, as the customer was shown it. Left out, `placementId` is the design's own placement, `viewId` the view its proof was previewed in, else the placement's first view, and `variant` the variant its proof was previewed on, else the view's default photo; `mockupId` names a photo instead. `size` caps the long edge in pixels. `v`, the design's `proof_id`, names the picture in the URL, so the answer is cached `immutable`; a `v` naming any other proof is refused `proof_changed`. An unknown design, placement, view, photo or variant, and a photo that is gone, are all `not_found`. A design with no proof, or whose personal data was erased, is `proof_not_found`, as its proof is. A design whose document the current model cannot read is refused `design_doc_unreadable`. A studio member reads it with their session, in the workspace the `x-tenant-id` header names.
         */
        get: operations["designs.mockup.get"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/designs/{id}/proof": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Fetch a design's proof image
         * @description The design's proof, as the customer was shown it, read with the credentials that read the design: the proof of its newest revision that has one. A commit from a proof gives revision 1 that proof, and each correction and restore renders a proof of the revision it writes, so a corrected design's proof shows what it says now. `v`, the design's `proof_id`, names the image's bytes in the URL itself, so the answer is cached `immutable`; a `v` naming any other proof (a URL made by hand, or for another design) is refused `proof_changed` rather than served under the wrong name. Without `v`, the proof's id is the answer's etag. Once the proof's file is gone (a rejected design's proof is released), the answer is `proof_not_found`. `width` serves it no larger than the box it is drawn in; each resize asked for with a key or through a link spends the tenant's render budget, and is refused `rate_limited` once it is spent.
         */
        get: operations["designs.proof.get"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/designs/{id}/reject": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Reject a committed design
         * @description Rejects the design, which then takes no correction and releases its proofs and pictures. `reason`, when given, is kept on the design and answered by its reads. Safe to retry: rejecting a design already rejected at `expectedRevision` (or at any revision, when none is given) answers success again and records nothing more, keeping the first reason; one approved, or rejected at another revision, is refused `not_committed`. `expectedRevision`, when given, is refused `revision_changed` once the design has been corrected since. Through a deciding proof page link, must carry `expectedRevision` (else `bad_request`), may not give a `reason` (`bad_request`), and is refused `proof_outdated` unless the design's proof shows its current revision, which a design committed without a proof never has.
         */
        post: operations["designs.reject"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/designs/{id}/request-changes": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Ask for changes to a design awaiting approval
         * @description Records a request for changes on the design, the customer's or a member's on their behalf, which stays awaiting approval; a later request replaces it, and every request is in the `design.changes_requested` events. Cancels a scheduled approval. Refused `design_erased` for a design whose personal data was erased. Through a proof page link, must carry `expectedRevision` (else `bad_request`), and is refused `proof_outdated` unless the design's proof shows its current revision, which a design committed without a proof never has. A member holding `designs:update` asks as they approve or reject.
         */
        post: operations["designs.requestChanges"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/designs/{id}/review": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Read a design as its customer reviews it
         * @description Where the design stands, whether its proof still shows it, and any open request for changes. Never the design's document or its fulfilment payload.
         */
        get: operations["designs.review.get"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/designs/{id}/revisions": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List a design's revisions
         * @description Every document the design has had, newest first: revision 1 is what was committed, and each correction or restore added the next. One page at a time; `nextBefore` reads the next older page.
         */
        get: operations["designs.revisions.list"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/designs/{id}/revisions/{revision}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Read one revision of a design
         * @description The document the design had as this revision. A print names the revision it rendered (`designRevision`), so this is the document a print shows. `choices` lists what the customer chose in it, in the order and with the labels of the template's form: each text they wrote, each picture they put in (an asset id) and each colour they picked (its palette entry's name, or none for a colour of their own, and its screen swatch).
         */
        get: operations["designs.revisions.get"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/designs/{id}/revisions/{revision}/image": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Draw a revision of a design
         * @description What the design's revision `revision` prints, drawn as its proof is but unwatermarked, read with the credentials that read the design. `width` draws it no larger than the box it is shown in. A JPEG, as a proof is, unless `format=png` asks for a PNG that keeps the design's transparency. A revision never changes but when the design's personal data is erased, and it is drawn through the output profile of the machine its blank goes to, so the answer carries an etag naming the revision, that erasure, the format, the renderer and that profile, and asking again with it is answered 304 without drawing. A drawing that had to leave out a picture the document names is answered `no-store`. A revision whose document the current model cannot read is refused `design_doc_unreadable`.
         */
        get: operations["designs.revisions.image.get"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/designs/{id}/revisions/{revision}/restore": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Restore an earlier revision of a design
         * @description A correction whose document is the named revision's: it is added as the design's next revision, and the design goes back to awaiting approval, as after any correction, with a proof of its own rendered now (`proofId`). Emits `design.edited` with `restoredFrom`. A revision whose document is the current one writes nothing, and answers `restored: false`. Refused once any print of the design has an order, and for a revision the current model can no longer read.
         */
        post: operations["designs.revisions.restore"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/events": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Pull the tenant's events after a given one
         * @description Catch up on events, for example after downtime: give `after` the id of the last event handled and follow `nextCursor` until it is null, which means nothing more is available yet; continue from the last id later. Events come in the order they were recorded, each in the envelope a webhook delivery's body carries; dedupe them by `id`.
         */
        get: operations["events.list"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/mcp": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Speak MCP to Pixel's tools
         * @description A stateless JSON-RPC MCP server (protocol versions `2025-11-25`, `2025-06-18` and `2025-03-26`) over POST alone: `initialize`, `ping`, `tools/list`, `tools/call` and `notifications/cancelled`. A connected store's member key acts as the member its user linked, exactly as an MCP key acts as the member who minted it: `tools/list` is the tools that member's MCP key would get, and each `tools/call` runs the tool's route as the member, judged by their grants, the workspace's features and its plan. A tool the member may not use answers `result.isError: true` with the route's reason; an unknown tool is JSON-RPC error `-32602`. There are no confirm cards: a destructive tool says so in `annotations.destructiveHint`, and a template change that needs an author's confirmation is refused in `isError`. The workspace must have `mcp`. The store's own integration key is refused `member_link_required`.
         */
        post: operations["mcp.request"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/orders": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List the tenant's orders, newest first
         * @description `printId` narrows the list to one print's orders, `designId` to the orders of every print of one design, `externalRef` to the orders placed under your own reference, matched exactly, `printshop` to the orders sent to one printshop connection, `status` to any of several statuses, `blankId` to one blank's orders and `variant` to one variant's, `submittedFrom` and `submittedTo` to the orders submitted between them, and `q` to the orders whose own reference, id or recipient's name starts with it; given several, an order must match all of them. `sort=updated` lists by when each order last changed, and `order=asc` the earliest first. `counts` says how many orders each status holds under the other filters.
         */
        get: operations["orders.list"];
        put?: never;
        /**
         * Place one order for the prints of one item
         * @description A secret key, an integration key, or a studio member holding `orders:create`. Places ONE order for every print in `prints`: the prints of one physical item, a front and a back of one shirt, made by one printshop as one item. The prints must be prints of designs committed on the same blank, each in a placement of its own, or all on no blank, completed or still rendering. An order of prints still rendering is written `awaiting_prints` and answered 201 at once; it goes to its printshop on its own once every print is complete, checked then against what needs the files (`technique_not_offered`, the sizes, the printshop's required keys), and a refusal then leaves it `failed` with `failureKind` naming it. A print of it that fails fails it `print_failed`, and prints not complete within three hours of placing fail it `prints_timed_out`. A print that failed is refused `409 print_not_completed`. `designs` names approved designs in place of their prints: the order makes a new print of each, as `POST /v1/prints` would, and waits for them, except that a standing design's order reuses the print of its current revision, completed or still rendering, and makes one only when there is none or it failed; an unknown design is `404 design_not_found`, one not approved `409 design_not_approved`, and nothing is written. Naming both `prints` and `designs`, or neither, is `400`. Every check that needs no files runs at placement: `422 print_without_placement` names a print committed before its placement was recorded, `422 mixed_blanks` answers prints on different blanks or some on a blank and some on none, and `422 duplicate_placement` two in one placement. Prints on a blank go to their blank's printshop, set when the blank was created; every print is checked against that printshop. `printshopId` naming another printshop is refused `422 printshop_differs_from_blank`, and naming the blank's own as an unknown field. Prints on no blank, such as a sign's front and back, go to the printshop the first print's design was committed with, else `printshopId`, else the workspace default, else are refused `409 print_needs_printshop`, except in a sandbox, where the order is placed with no printshop (`printshopConnectionId` null, `adapter` `none`); a print whose design was committed with another printshop is refused `422 print_committed_elsewhere`, naming it. A printshop that cannot make several prints as one item answers `422 printshop_cannot_combine`, and prints whose designs disagree on what the printshop makes one item from answer `422 prints_disagree` naming the key: nothing is written either way. One print places exactly the order `POST /v1/prints/{id}/orders` would. `quantity`, `externalRef`, `recipient`, `shippingAddress` and the `Idempotency-Key` header are as there; the first print's design's captured delivery is the one the order takes when the body names neither a recipient nor an address. A partner refusing the order is still a 201: the order is recorded as `failed`. A printshop the merchant paused takes no order: one going there is refused `409 printshop_paused`, naming it, and nothing is written. A print made by a method its printshop does not print with, where the printshop states what it prints with, is refused `422 technique_not_offered`, naming the placement, the method and the printshop's, and nothing is written. A placement its blank says an order must print, left without a print, is refused `422 placement_unfilled`, naming it, and nothing is written. A design has one live order, in any status but `failed` and `cancelled`, whoever placed it: an order of prints of a design that has one, or naming such a design, is refused `409 design_already_ordered`, naming the design and its newest live order, and nothing is written; two sent at once place one. `reorder: true` orders it again on purpose. A standing design is never refused `design_already_ordered`: it is ordered on every sale. A repeat with the first request's `Idempotency-Key` is answered with the first order before this is asked.
         */
        post: operations["orders.create"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/orders/{id}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Read one order, with its history */
        get: operations["orders.get"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        /**
         * Set an order's status by hand
         * @description A secret key moves an order forward by hand, for a printshop with no API of its own such as the local one: printed, shipped (optionally with `tracking`) or failed (optionally with a `reason`). An order moves forward only, never out of shipped, failed or cancelled, and never to cancelled, which only `POST /v1/orders/{id}/cancel` reaches by asking its printshop.
         *
         *     An order whose submission's answer was lost is `outcome_unknown`. Once you have asked its printshop, settle it: `failed` when the printshop does not have it, after which `POST /v1/orders/{id}/retry` submits it again, or `submitted` when it does, optionally with `externalOrderRef`, the printshop's own reference for it, so its status is followed from then on. A connected store's integration key and a studio member holding `orders:update` may make these two moves and no other. Settling needs a `reason`, kept in the audit log with who settled it; refused `422 order_status_reason_required` without one. A reference another order holds, or one other than the order's own, is refused `409 order_reference_taken`.
         *
         *     In a sandbox, whose orders reach no printshop, an integration key and a member move an order as a secret key does, so a store can rehearse an order shipping or failing.
         *
         *     A `reason` with any status but `failed` is kept in the audit log only. Any other move is refused `409 order_status_not_allowed`.
         */
        patch: operations["orders.update"];
        trace?: never;
    };
    "/v1/orders/{id}/cancel": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Cancel an order before it is made
         * @description A secret key, or a connected store's integration key or a studio member holding `orders:update`. Asks the order's printshop to stop it, and moves it to `cancelled`, a final status, only once the printshop says it did: `order.cancelled` is emitted. An order in `held`, `awaiting_prints`, `submitted`, `queued`, `outcome_unknown` can be asked about; one already cancelled is answered unchanged. An order still waiting for its prints (`awaiting_prints`) is cancelled at once, without asking a printshop, which has not been handed it. An order left at its printshop is refused `409 order_at_printshop`, whose `cause` says why: `made` (printed or shipped), `begun` (the printshop has begun it and did not cancel it), `cannot_cancel` (its printshop cannot stop orders), `not_connected` (its printshop is no longer connected), or `status_moved` (the printshop cancelled it, but it shipped meanwhile). Ask the printshop. A failed order is refused `409 order_status_not_allowed`, and one whose submission has not been answered yet `409 order_in_flight`. A printshop that could not be reached is `503 cancel_unavailable`, and the order stands; `retryable` says whether asking again may work. Refunds are your store's: cancelling an order moves no money.
         */
        post: operations["orders.cancel"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/orders/{id}/deliveries": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Read an order's step delivery log */
        get: operations["orders.deliveries.list"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/orders/{id}/delivery": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        /**
         * Add or change a sent order's address
         * @description A secret key, a connected store's integration key, or a studio member holding `orders:update`. Gives an order its `recipient` and `shippingAddress` after it was sent: one placed without them, or one whose customer moved. Both are checked as `POST /v1/orders` checks them, and an address without the postcode its printshop needs is refused `422 postal_code_required`.
         *
         *     The order's printshop is told, and the order's `delivery` says what it made of it: `accepted`, `refused` (in its own `words`; the order keeps the address the printshop has), `sending` while it is being told, or `carried` when what the printshop had not been sent yet takes the new address, so nothing extra is sent. A printshop that takes no address changes is refused `409 address_change_not_accepted`, naming it: a custom printshop takes them when its `acceptsAddressUpdates` is on, and an integration when it can tell its partner. An order that has shipped, failed, been cancelled or had its personal data erased, whose outcome is unknown, whose submission has not been answered yet, or that its printshop is already making is refused `409 order_past_address_change`, naming its status. A printshop that could not be told is `503 address_change_unavailable`, and nothing changed.
         *
         *     Each change emits `order.delivery_changed`, again when a change that was `sending` is answered; neither carries the address. Send an `Idempotency-Key` to make a retried request safe.
         */
        patch: operations["orders.delivery.update"];
        trace?: never;
    };
    "/v1/orders/{id}/erase-personal-data": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Erase an order's personal data
         * @description A secret key, or a connected store's integration key or a studio member holding `orders:update`. Erases the order's `recipient` and `shippingAddress`, what a custom printshop's delivery steps were rendered with, and every stored reason the order failed (its `lastError`, its history's and its notifications'), which may repeat them; a step not yet sent is closed as failed. The order itself stays, with its print, status, history, quantity and `externalRef`, which is your own reference and is not erased. `personalDataErasedAt` says when. Refused `409 order_in_flight` until the order has shipped, failed or been cancelled, since its printshop may still need the address. Erasing an order already erased answers it unchanged. An erasure cannot be undone, and does not reach what the printshop was already sent.
         */
        post: operations["orders.erasePersonalData"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/orders/{id}/job": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Read an order as its printshop makes it
         * @description Where the order stands, how it ships once shipped, and the job ticket to make it by: the print's ticket with the order's copies, recipient and address. `ticket` is the lead print's, for `machineProfile` when it is asked; `prints` holds every print of the order, the lead first, each with its ticket for its own machine. A failed or cancelled order has no ticket.
         */
        get: operations["orders.job.get"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        /**
         * Report how an order's job stands
         * @description The order marked printed, shipped (optionally with tracking) or failed (optionally with a reason), by the same rules as `PATCH /v1/orders/{id}`, and answered as its job. A printshop link gives a reason with failed only; a secret key may give one with any status, and must to settle an order whose outcome is unknown. A printshop link sending shipped with tracking for an order already shipped corrects its tracking: the order stays shipped, and `order.tracking_changed` (`order.tracking_added` for an order shipped without any) tells the store.
         *
         *     A member holding `orders:update` reports for a printshop a person works, one that takes its orders as delivery steps, as its link does: printed, shipped or failed, a reason with failed only, never out of an unknown outcome. The move is audited as theirs. An order to a printshop whose API reports on it is refused `409 order_status_not_allowed`; in a sandbox a member moves an order as `PATCH /v1/orders/{id}` lets them. An MCP key is answered the job without its tickets, which carry who the order is for and where it ships.
         */
        patch: operations["orders.job.update"];
        trace?: never;
    };
    "/v1/orders/{id}/job/bundle": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Fetch every file of an order's print as one zip
         * @description Every file one of the order's prints (`printId`, required for an order of several) can be handed out as, for the order's machine profile, or `machineProfile`, another of its printshop's, or `settings`, output settings for this download only: each part of the process file and, where the print has one, the separated file, as the list of its files names them, in one zip, in a folder named for the machine (`as-ordered` for the order's own), with the job ticket drawn for that machine as `job-ticket.json`. For each set `add` names, the same print for another machine profile of the order's printshop, or with output settings for this download only, in a folder of its own. A file the order's file door would refuse with `spot_plate_required` is left out. Not for a failed or cancelled order.
         */
        get: operations["orders.job.files.bundle"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/orders/{id}/job/file": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Fetch the print file of an order
         * @description A file the printshop prints the order from, of one of its prints (`printId`, required for an order of several): by default its machine profile's default part of the file it was sent, as its delivery links hand it out. `machineProfile` names another of its printshop's profiles, or `settings` output settings for this one download (as the list of its files takes them); `part` another part (`combined`, `print` or `cut`), and `file` the `process` or `separated` file. The parts share the trim and bleed boxes, and the artwork is the same bytes in `combined` and `print`. With no machine, or one that names no cut name, the default part is `print`, the stored file; `combined` then carries a `CutContour` path, and a rectangular die is drawn as a cut path too. Not for a failed or cancelled order.
         */
        get: operations["orders.job.files.get"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/orders/{id}/job/files": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List the files an order can be fetched as
         * @description Every file one of the order's prints can be handed out as (`printId`, required for an order of several), for the order's machine profile, or `machineProfile`, another of its printshop's, or `settings`, output settings asked for one download (a JSON object of a machine profile's cut name, marks, crop marks, mark offset, mirror, bleed trim, white and varnish): each part of it (`combined`, the print with its cut path on a layer that never prints; `print`, the print alone; `cut`, the cut path alone, on a page of its own) of the process file and, where the print has one, the separated file. All three parts share the trim and bleed boxes. A machine that names no cut name is handed the print alone, and the other parts are drawn under `CutContour`. Each file says whether the printshop is handed it, which is the default, and the address it is fetched from; `settings` answers the settings the files are drawn with, null when none are drawn. A file the order's file door would refuse with `spot_plate_required` is left out, and the list is refused so only when it would leave out every file. A failed or cancelled order lists none.
         */
        get: operations["orders.job.files.list"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/orders/{id}/progress": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Read an order as its customer follows it
         * @description Where the order has got to, how it ships once shipped, when it was placed, and the steps it took. A failed order that was sent again answers as the order that took its place (one that names it as replaced, or a later order of the same print, quantity, reference and variant), under this order's id. Never the printshop, its reference, why an order failed, the recipient or the fulfilment payload.
         */
        get: operations["orders.progress.get"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/orders/{id}/reroute-targets": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List the blanks a failed order could be sent to
         * @description A secret key, or a connected store's integration key or a studio member holding `orders:create`. Every blank of the workspace but the order's own, at any printshop, for `POST /v1/orders/{id}/retry` with `reroute`: those the order's prints fit first, then the rest, each half by name, 50 to a page with the total. A print fits a placement whose largest print holds its trim size, width against width and height against height, and is that size where the placement is printed across its whole area, and whose print method is the one it was made by; it goes to the placement of its own placement's name when the blank has one. A fitting blank lists each print's placements; another says why, per print (`print_exceeds_placement` with both sizes, `print_short_of_area` with the print's size and the area of a placement printed across its whole area, `technique_differs` with both methods, `technique_unknown`, `no_placement_fits`), or `too_few_placements` when they cannot take one print each. Refused 409 as a retry is when the order cannot be submitted again.
         */
        get: operations["orders.rerouteTargets"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/orders/{id}/retry": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Submit a failed order again
         * @description Places a new order for the same print as a failed one, recording which order it replaces. It goes to the printshop the failed order went to, which is its blank's: a blank's printshop is set when the blank is created. A body naming a printshop is refused as unknown. With `reroute`, the order goes to another blank and its printshop instead, the failed order's printshop is not called, and no blank moves; it is refused 422 when that blank is unknown or the failed order's, when a print is left without a placement or two share one, when a print goes elsewhere than the placement of its own name, and when a print does not fit its placement (`print_exceeds_placement`, `print_short_of_area`, `technique_differs`, `technique_unknown`). Refused when the order is not `failed`, reached the printshop, or has already been submitted again; refused 422, writing nothing, when the printshop it would go to cannot take it or the design lacks a key that printshop requires, 409 `printshop_paused` when that printshop is paused, and 422 `technique_not_offered` when it does not print with the print's method, and 422 `placement_unfilled` when a placement the blank must print has no print.
         */
        post: operations["orders.retry"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/pixel/apply": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Confirm a Pixel card
         * @description Applies an open card of the caller's conversation, as the member it belongs to: a studio member's, or one a member holds in a connected store, through their member key.
         */
        post: operations["pixelApplications.create"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/pixel/conversation": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Read the author's open Pixel conversation
         * @description A studio member's open conversation, or the one a member holds in a connected store: a member key reads the conversation its member's turns in that store hold, never the member's studio one or another store's.
         */
        get: operations["pixelConversation.get"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/pixel/designer": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Ask Pixel to change a customer's design
         * @description Pixel, for the customer in the designer: from their prompt and their values as they stand, Pixel changes what the template offers them, within what each field allows, and may generate a picture for an offered picture or cut the customer's picture out of its background, as the template's settings allow. It never changes what the template keeps fixed. The answer is the values with Pixel's changes, for the designer to apply. Paid from the workspace's credits, within the template's limits for one designer session (`x-pixonaut-session`, required) and the workspace's monthly ceiling. Whatever stops it — the template or the workspace has it off, a limit or the ceiling is reached, or the credits run out — it answers `503 pixel_unavailable` and nothing else, for the designer to say it did not work.
         */
        post: operations["pixel.designer"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/pixel/dismiss": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Dismiss a Pixel card, or the conversation
         * @description With a card, dismisses it and tells Pixel. Without one, ends the conversation: a member key ends its member's conversation in that store this way, and its next turn with no conversation starts a new one.
         */
        post: operations["pixelDismissals.create"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/pixel/turns": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Take one Pixel turn, streamed as SSE
         * @description A studio member's turn, or a connected store's: a member key acts as the member the store's user linked, whose conversation in that store it is and whose permissions bound what Pixel does, and the turn is charged to the workspace through the store's key. The store's own integration key is refused `member_link_required`.
         */
        post: operations["pixelTurns.create"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/pixel/turns/{turnId}/tool-results": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Answer a call of one of the store's own tools
         * @description Posts what a tool the store declared answered, by the `callId` of its `tool_call` event, and carries the turn on as a new stream of the same events. While another call of the same pause is still unanswered, the stream ends paused at once. A call is answerable for five minutes; after that, or once answered, it is refused `call_not_pending`.
         */
        post: operations["pixelTurns.toolResults.create"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/prints": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List the tenant's prints
         * @description Newest first unless `sort` says otherwise. `status`, `apiKeyId`, `designId` and `q` narrow the list, and `counts` says how many each status holds under the rest. Rows carry no job ticket; read one print for it. Each row's `printshops` names the distinct printshops its orders went to, and `orderCount` says how many orders hold it; they are empty and 0 for a studio member without `orders:read`, since where and how often a print was ordered is order data.
         */
        get: operations["prints.list"];
        put?: never;
        /**
         * Print an approved design
         * @description Makes the print files for an approved design. Answers `202` with the print as soon as it is reserved, and renders it after the answer: read it at `Location` until it is `completed` or `failed`, or wait for `print.completed` or `print.failed`. With `Prefer: wait` it answers once the print has rendered, `201` with its job ticket, or `render_failed`. A studio member or a connected store's integration key needs `prints:create`.
         */
        post: operations["prints.create"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/prints/{id}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Read one print
         * @description A studio member without `designs:read` reads the job ticket without its `fulfilmentPayload`: that is the design's consumer bag, which reading the design would need the grant for. A completed print read by a secret key, or by a member holding `orders:read` or `orders:create`, carries `orderPrintshop`: where an order placed for it goes, unless that could not be worked out.
         */
        get: operations["prints.get"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/prints/{id}/bundle": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Fetch every file of a print as one zip
         * @description Every file the print can be handed out as stored, each part and file, in one zip, in the folder `as-stored`; and for each set `add` names, the same print drawn for a machine profile of the tenant's printshops (a studio member needs `printshops:read` to name one) or with output settings for this download only, in a folder of its own. A file a machine makes none of is left out. Getting a print's files without an order counts as an order the first time, unless an order of the print was placed that is not held or cancelled; getting them again is free. Past the month's orders, free's get is refused (`plan_limit_reached`, `limit: "orders"`); a paid plan's draws one from the order balance, and is refused while it is empty (`order_balance_empty`). Since it counts as an order, the first get takes `orders:create` (`forbidden` without it); a print counted already is read with `prints:read`. A studio session's first get must come from the studio (`session_origin_forbidden` from a page elsewhere).
         */
        get: operations["prints.files.bundle"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/prints/{id}/file": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Fetch a print's file
         * @description The print's file as stored, or drawn for `machineProfile`, any machine profile of the tenant's printshops (a studio member needs `printshops:read` to name one), or for `settings`, output settings for this one download; `part` names the part (`combined`, `print` or `cut`), the print alone by default, and `file` the `process` or `separated` file. With no machine, or one that names no cut name, the default part is `print`, the stored file; `combined` then carries a `CutContour` path, and a rectangular die is drawn as a cut path too. Getting a print's files without an order counts as an order the first time, unless an order of the print was placed that is not held or cancelled; getting them again is free. Past the month's orders, free's get is refused (`plan_limit_reached`, `limit: "orders"`); a paid plan's draws one from the order balance, and is refused while it is empty (`order_balance_empty`). Since it counts as an order, the first get takes `orders:create` (`forbidden` without it); a print counted already is read with `prints:read`. A studio session's first get must come from the studio (`session_origin_forbidden` from a page elsewhere).
         */
        get: operations["prints.files.get"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/prints/{id}/files": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List the files a print can be fetched as
         * @description Every file the print can be handed out as: as stored, for `machineProfile`, any machine profile of the tenant's printshops, or for `settings`, output settings asked for one download (a JSON object, as the order's list of files takes it): each part (`combined`, `print`, `cut`) of the process file and, where the print has one, the separated file, with the address it is fetched from. `settings` answers the settings the files are drawn with, null when none are drawn (a print whose ticket cannot be read). `machineProfiles` lists the profiles to choose from, each with its printshop; a studio member sees them, and may ask for one, only with `printshops:read`. `counted` says whether the print was counted as an order already, so getting its files is free.
         */
        get: operations["prints.files.list"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/prints/{id}/orders": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Submit a print to its printshop
         * @description A secret key, or a connected store's integration key or a studio member holding `orders:create`. Places an order for a print with its blank's printshop, set when the blank was created. A print still rendering is waited for: the order is written `awaiting_prints` and goes to its printshop on its own once the print is complete, as `POST /v1/orders` describes; a print that failed is refused `409 print_not_completed`. A print with no blank goes to the printshop its design was committed with, else the one `printshopId` names, else the tenant's default, and is refused `409 print_needs_printshop` with none; in a sandbox it is placed with no printshop instead (`printshopConnectionId` null, `adapter` `none`). The order records which. For a print on a blank, `printshopId` naming another printshop is refused `422 printshop_differs_from_blank`, and naming the blank's own as an unknown field. A printshop named here that cannot take the order (unknown, disconnected, or unavailable because its integration is no longer registered) is a 422 and no order is written, as is a design whose fulfilment payload lacks a key that printshop requires. `quantity` is how many copies this order wants, 1 when the body leaves it out; the same print can be ordered again with another, with `reorder: true`. A design has one live order, in any status but `failed` and `cancelled`, whoever placed it: an order of a print of a design that has one is refused `409 design_already_ordered`, naming the design and its newest live order, and nothing is written; two sent at once place one. A standing design is never refused `design_already_ordered`: its print is ordered on every sale. A repeat with the first request's `Idempotency-Key` is answered with the first order before this is asked, and a replacement of a failed order needs no `reorder`. `externalRef` is your own reference for the order (your order or line id; not unique, and `GET /v1/orders?externalRef=` finds it), and `recipient` and `shippingAddress` say who it is for and where it ships; all three are optional, reach the printshop on the job ticket, and are never written to logs. The design's first order takes the recipient and address its customer gave on its address capture page (`PUT /v1/designs/{id}/delivery`) when this body names neither; a body naming either is used alone, and the customer's answer is dropped. A partner refusing the order, or a printshop that has been disconnected, is still a 201: the order is recorded as `failed`, naming it and why (`printshop_disconnected`). A printshop the merchant paused takes no order: one going there is refused `409 printshop_paused`, naming it, and nothing is written. A print made by a method its printshop does not print with, where the printshop states what it prints with, is refused `422 technique_not_offered`, naming the placement, the method and the printshop's, and nothing is written. A placement its blank says an order must print, left without a print, is refused `422 placement_unfilled`, naming it, and nothing is written. With `replacesOrderId`, the order replaces a failed order of this print, as `POST /v1/orders/{id}/retry` would but with what this body asks for, and is refused as a retry is.
         */
        post: operations["prints.orders.create"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/printshop-connections": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List the tenant's printshop connections
         * @description Each connection's id, name, adapter, whether it is active and whether it is the tenant's default printshop, active first; a member is also answered its `counts`: the blanks it makes, its open orders and all its orders, `blanks` null without `blanks:read` and the order counts null without `orders:read`. `q` keeps the connections whose name holds it, case aside.
         */
        get: operations["printshopConnections.list"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/proofs": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Render a proof
         * @description Validates a customer's payload as `POST /v1/validate` does, renders the proof image a customer approves, and answers with a signed link to it. The proof is fitted to the placement the request names, and the proof token commits the design later with that blank and placement. On a blank whose print areas change with its size, it is fitted to the size its `variant` or `variantRow` names, or to the blank's reference row when it names neither, and a token of a proof that named none is refused `variant_required` at commit.
         */
        post: operations["proofs.create"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/proofs/layout": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Render a proof of a design on a panel layout
         * @description Validates a customer's payload on a blank's panel layout, renders the proof image they approve, and answers with a signed link to it. The template is resolved once on the layout's canvas at the size the request names (`variant` or `variantRow`, as on `POST /v1/proofs`), and the image is that canvas. Its token commits one design per placement the layout has a window for, at `POST /v1/designs/layout`; a proof answered at the blank's reference row, naming no size, is refused `variant_required` there on a blank whose print areas change with its size. A layout the blank does not have is refused `unknown_layout`; one whose windows no longer fit the blank's print areas at that size, `layout_out_of_date`.
         */
        post: operations["proofs.createThroughLayout"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/sessions/{id}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        post?: never;
        /**
         * Wipe a session's unretained uploads and proofs
         * @description Deletes the pictures a customer uploaded and the proofs made for them in one designer session, for a "clear my design" button. Anything a committed design or a published template still uses is kept. A secret key is also told how many uploads and proofs were kept; a publishable key is not, since it cannot prove the session is its caller's.
         */
        delete: operations["customerSessions.delete"];
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/share-links": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List the tenant's share links
         * @description Links that still work, of the kinds the caller may hand out (to a connected store's integration key, every link its store handed out, designer links included), newest first or by expiry, 100 a page at most, narrowed by kind, subject, who handed them out, whether they carry a visit, when they stop working, and text. Never the token itself. `counts` says what each kind, each source and the visit filter would answer, each under every other filter, in the same read.
         */
        get: operations["shareLinks.list"];
        put?: never;
        /**
         * Create a share link
         * @description Opens one hosted page about one template, design or order to whoever holds the link. Answers with the token, which is never shown again. A member may hand out only what they hold themselves; a printshop page takes `printshops:update`, an address capture page `orders:create`. A connected store's integration key hands out what its grants hold, such as a deciding proof page it emails its customer, who approves or rejects there; the page is drawn in the brand named by `brandId`, or the workspace's default.
         */
        post: operations["shareLinks.create"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/share-links/revoke": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Withdraw several share links
         * @description With `ids`, withdraws up to 100 links and answers each `revoked` or `not_found`; a link the caller could not have handed out (to a connected store's integration key, one its store did not hand out) is `not_found`, as `DELETE /v1/share-links/{id}` answers it. With `createdByKeyId`, withdraws every working link that api key or connected store handed out and answers how many, without revoking the key, which may hand out new ones. Each link withdrawn is audited as a single withdrawal is.
         */
        post: operations["shareLinks.revokeMany"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/share-links/{id}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        post?: never;
        /**
         * Revoke a share link
         * @description The link's page stops opening at once. Revoking one already revoked changes nothing. A link the caller could not have handed out (to a connected store's integration key, one its store did not hand out) is answered as not found.
         */
        delete: operations["shareLinks.delete"];
        options?: never;
        head?: never;
        /**
         * Rename a share link or edit its settings
         * @description Changes a working link's name or, on a designer link, its design limit and anything it was handed out with, each change audited. The link keeps its id, token and address, so a store's product page need not change: a visit after the change opens on the new settings, and a design made before keeps what it was made with. A designer link takes every field `POST /v1/templates/{id}/designer-links` takes, judged as that route judges them, and `templateId` for the template it opens; what its page shows (the blank and placement, sizes, photos, views, variants, `sides`, `layout` and `linkedPlacements`) is sent whole, and any of it replaces all of it. It is held to the rules a new link is: a side for every placement its blank says an order must print (`422 placement_unfilled`, naming it), sizes its blank takes (`422 variant_row_invalid`), a panel layout its blank has (`422 unknown_layout`), that still fits the blank at the size the link sells (`409 layout_out_of_date`) and whose canvas is the template's shape (`422 layout_wrong_ratio`), and linked sides that print one template (`422 linked_templates_differ`); its linked groups are kept as a new link keeps them, from its setting or what its blank suggests. Every other field absent is left as it is, and null removes it. Any of them on another kind is refused `designer_settings_not_allowed`. A name another working link holds is refused `share_link_name_taken`; a withdrawn or expired link, or one the caller could not have handed out (to a connected store's integration key, one its store did not hand out), is answered as not found. Nothing is changed when any part is refused.
         */
        patch: operations["shareLinks.update"];
        trace?: never;
    };
    "/v1/share-links/{id}/designer": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Read what a designer link was handed out with
         * @description A working designer link's settings, as `POST /v1/templates/{id}/designer-links` took them and `PATCH /v1/share-links/{id}` changes them: what its page shows, where it sends the shopper back to and with what, its language, frame, name, design limit and expiry. Never its token. Any other kind of link, a withdrawn or expired one, or one the caller could not have handed out, is answered as not found.
         */
        get: operations["shareLinks.designer.get"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/share-links/{id}/regenerate": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Give a share link a new address
         * @description Replaces a working link's token: the old address opens nothing from then on, and the link keeps its id, kind, subject, settings, expiry, history and design count. Answers with the new token, which is never shown again. For a link whose address was lost: a designer link keeps its address, which the list answers as `url`, and is refused `address_kept`, unless it was made before addresses were kept, when it is given one. A withdrawn or expired link, or one the caller could not have handed out (to a connected store's integration key, one its store did not hand out), is answered as not found.
         */
        post: operations["shareLinks.regenerate"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/storage": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Read the tenant's storage use
         * @description Bytes used against the quota, counting every finished asset at its full size, and how many there are, in all and by category: library pictures (`assets`), customers' design uploads (`customerUploads`), blanks' photos (`blankPhotos`) and everything in the sandbox (`sandbox`). A workspace and its sandbox share the quota, so both read the same numbers; a copy Sync made counts only once live has deleted the upload it copies. The categories add up to `usedBytes` and `fileCount`.
         */
        get: operations["storage.get"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/templates": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List the tenant's templates
         * @description A key is answered a page of the tenant's live templates by name (`items`, `total`, `page`, `pageSize`): each one's template id, base id, name, latest version, the ratio and tolerance a print size is judged against, the field keys its offered fields carry, and `previewUrl`, a link to its preview that opens with no key for an hour or two. `q` keeps the templates whose name holds it, case aside; a key may ask for `status=live` alone. With `ids`, any caller is answered those of the templates named that are live, in one page; a publishable key may read nothing else here, and is refused `secret_key_required` without them.
         */
        get: operations["templates.list"];
        put?: never;
        /**
         * Publish a template version
         * @description Writes `template` as the published version `id@version` in one step, after the checks a studio publish runs: the author's own defaults must satisfy the template's constraints, and the publish-only rules must hold. A published version never changes, so a version that already exists is refused with `version_exists`. The version keeps the showcases of the latest version before it; one published while this one is judged holds showcases of its own, and this one is then refused with `showcases_changed`.
         */
        post: operations["templates.publish"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/templates/{id}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Read a published template
         * @description The whole published document, which the designer validates and lays out against, and the form generated from it. `optionLabels` holds the tenant's own words for the options the template offers, when it has named any: each shape's, die's or picture's name for `lang`, else for the workspace's default language, else its own name; `dieShapeId` names the die-cut the author chose, `layerShapeIds` the shape each customer-editable shape layer starts on, by layer id, and `offeredShapes` holds the outline of every shape a customer may pick, for the die-cut or a shape layer. `printMargins` is the reading tenant's default bleed and safe area, which artwork with no blank prints with, and `printFloorDpi` the minimum print resolution its pictures are judged against when a design is made: the template's own, else the tenant's. `fieldKeys` names the field keys its offered fields carry, and `previewUrl` links to its preview, opening with no key for an hour or two. `status` is the template's state now, whichever version is read: `live`, or `paused` once a member has paused it, when customers cannot design on it although its versions are still served. A pause and a resume are each delivered as `template.live_changed`; after a missed delivery, `status` is the state to trust. `poweredBy` is whether the designer shows "Powered by Pixonaut" for the workspace: decided by its plan, then its own setting. `pixel` is whether the designer offers the customer Pixel: the template has Pixel for customers on, and the workspace has not turned it off. A text naming dynamic values, such as `Class of {date.year}`, is answered with them written for today in `tz`, else in the workspace's timezone. The values are `{date.year}`, the current year, `2026`; `{date.nextYear}`, next year, `2027`; `{date.month}`, the month's name, `October`; `{date.academicYear}`, the academic year, starting on 1 August: `2026/27` from August 2026 to July 2027; `{date.dayMonth}`, the day and month, `October 21`; `{date.monthYear}`, the month and year, `October 2026`; `{date.long}`, the full date, `October 21, 2026`; `{date.short}`, the date in digits, `10/21/2026`; `{date.iso}`, the date as ISO 8601 writes it, `2026-10-21`; `{date.custom(<pattern>)}`, the date in a pattern of your own, Unicode's date-pattern letters `y`, `M`, `L`, `d` and `E` with text in single quotes: `{date.custom(d.M.yyyy)}` writes `21.10.2026`, `{date.custom(MMM ''yy)}` writes `Oct '26`. They are written in `lang`, else in the workspace's default language, else English; a value whose name carries a language after a colon, `{date.long:sv}`, is written in it whatever `lang` says. `workspaceLanguage` is the template's workspace's default language, one of the customer-facing languages' codes (English until it chooses one): what the SDK designer is shown in when its mount names no `locale`. `showcases` lists the template's showcases by id and name, the sets of example values its preview and mockup images are drawn with when their `showcase` names one, each with `previewUrl`, a link to its preview that opens with no key as the template's own does. An SDK names its release in `x-pixonaut-sdk-version`; a release whose renderer cannot draw the template is refused `sdk_outdated`, naming the first release that can.
         */
        get: operations["templates.get"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/templates/{id}/constraints": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Read what a template's print size is judged by
         * @description The template's declared aspect ratio and the tolerance around it, so a consumer can check a size itself before asking `POST /v1/templates/{id}/print-size`. `fit` says how the artwork sits inside a legal box. Naming a `blankId` and `placementId` (both or neither) adds that placement's bounds: its largest and default print box, the box a proof or design naming it and no size prints at (`printWidthMm` × `printHeightMm`, the template's ratio fitted into the default box), and the bleed and safe area it prints with. A client draws its live preview against that box and those margins so it frames the design as the proof does. A named placement that does not resolve, or whose stored sizes are unusable, is refused with `unknown_placement`.
         */
        get: operations["templates.constraints.get"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/templates/{id}/designer-links": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Hand out a hosted designer for a template
         * @description A designer share link for the template's live version that mounts the designer with what the store sells it on: the blank and placement every proof is fitted to, the store's size menu and its colourway photos, and which size and photo start selected, exactly as the SDK takes them on a store's own page. A front and a back are one link with `sides`: one hosted page with a step per side, each side its own menus and, when it names one, its own template. A link holds two to 10 sides; one with more than 4 is made, and answered with a `sides_over_recommended` warning, since each side is one more step on the page and one more designer in the shopper's browser. The sides of a garment each name a placement on its blank; the sides of an item with no blank, such as a sign or a coaster, name neither `blankId` nor `placementId`, and each is proofed on its template alone. Every side names a blank and its placement or neither, and either every side is on a blank or none is. With a `returnUrl`, approving makes a proof and sends the shopper back to `returnUrl?state=…&proofToken=…` (with `sides`, `returnUrl?state=…&proofToken[front]=…&proofToken[back]=…`), cancelling to `returnUrl?state=…`. `locale` shows the page and the designer in one of `en`, `sv`, `de`, `fr`, `es`, `nl`, `da`, `nb`, `fi`, and the returned `url` then carries `?lang=<locale>`; absent, they are shown in the workspace's default language. `layout` fixes how every side's form lays out its steps, `page` or `steps`; absent, each side's form follows its template's own `form.layout`, and is a page when the template names none. A link carrying `state`, which names one shopper's visit, works for 24 hours; one without it works for the `expiresInDays` it names, or until withdrawn. Every size a side offers is judged as the shopper's approval would judge it, against the side's template and placement, and one it would refuse is refused `print_size_illegal`, naming the side, the size's place in the menu and why. On a blank, the link holds a side for every placement its blank says an order must print: one leaving such a placement out could never be ordered, and is refused `422 placement_unfilled`, naming it. A link through a blank's panel layout is refused `unknown_layout` when the blank has no layout of that name, `layout_out_of_date` when the layout no longer fits the blank at the size the link sells, and `layout_wrong_ratio` when the template's shape is not the layout's canvas, which the template is drawn on. `name` names the link for the workspace, and `designLimit` limits the designs its page makes. The link's address is kept, and the share-link list answers it again as `url`. A member needs what handing out a designer needs; a connected store's integration key, `templates:read` and `designs:update`.
         */
        post: operations["templates.designerLinks.create"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/templates/{id}/fitting-blanks": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List the blank placements a template fits
         * @description Every placement on the tenant's blanks, with the verdict for this artwork at the size it would print at there. It answers geometry, not whether the pairing is sold, and it answers for a draft or paused template too. The page is of BLANKS: one blank with three placements is three items, so page on `page` and `total`, not on the number of items. `q` keeps the blanks whose name holds it, case aside.
         */
        get: operations["templates.fittingPlacements.list"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/templates/{id}/print-size": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Check a print size against a template
         * @description Judges `widthMm` × `heightMm` against the template's declared ratio and, when the body names a `blankId` and `placementId` (both or neither), against that placement's maximum print area. An illegal size is still a 200: the verdict says which check it failed. A body with `sizes` (up to 50) in place of one size judges each against the same placement, answering `verdicts` in the order asked. A named placement that does not resolve is refused with `unknown_placement` rather than judged without its bounds.
         */
        post: operations["templates.printSize.validate"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/validate": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Check a customer's payload against its template
         * @description Validates the values a customer gave a published template, and the placement and print size the request names, without rendering or storing anything. A named placement that does not resolve is refused with `unknown_placement`. On a blank whose print areas change with its size, the payload is judged at the size its `variant` or `variantRow` names, or at the blank's reference row when it names neither.
         */
        post: operations["payloads.validate"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/webhooks": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** List the tenant's webhook endpoints */
        get: operations["webhookEndpoints.list"];
        put?: never;
        /** Register a webhook endpoint */
        post: operations["webhookEndpoints.create"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/webhooks/{id}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        post?: never;
        /** Delete a webhook endpoint */
        delete: operations["webhookEndpoints.delete"];
        options?: never;
        head?: never;
        /** Switch a webhook on or off, or set its events */
        patch: operations["webhookEndpoints.update"];
        trace?: never;
    };
    "/v1/webhooks/{id}/deliveries": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** List an endpoint's recent deliveries */
        get: operations["webhookEndpoints.deliveries.list"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/webhooks/{id}/deliveries/redeliver-failed": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Requeue every failed delivery of an endpoint */
        post: operations["webhookEndpoints.deliveries.redeliverFailed"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/webhooks/{id}/deliveries/{deliveryId}/redeliver": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Requeue one delivery */
        post: operations["webhookEndpoints.deliveries.redeliver"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v1/webhooks/{id}/ping": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Send an endpoint a signed test request */
        post: operations["webhookEndpoints.ping"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
}
export interface webhooks {
    "asset.created": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** asset.created */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["AssetCreatedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "asset.deleted": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** asset.deleted */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["AssetDeletedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "asset.updated": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** asset.updated */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["AssetUpdatedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "automation.webhook": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * automation.webhook
         * @description Sent by an automation's webhook step to the endpoint the step names, whatever event types that endpoint takes, and retried and logged as its other deliveries are. Its payload is the JSON the step wrote. No event: it is not a type an endpoint subscribes to, and it never appears in `GET /v1/events`.
         */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": {
                        automation: {
                            /** @description The automation's id. */
                            id: string;
                            /** @description What the automation was called when it acted. */
                            name: string;
                        };
                        /** @description When the step ran, in milliseconds since the Unix epoch. */
                        createdAt: number;
                        /** @description `awh_…`, the same for every attempt of the same firing's step, so a receiver can drop one it has already handled. */
                        id: string;
                        /** @description The JSON the automation's webhook step wrote, its placeholders filled in. */
                        payload?: unknown;
                        /** @enum {string} */
                        type: "automation.webhook";
                        via: string;
                    };
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "blank.created": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** blank.created */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["BlankCreatedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "blank.deleted": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** blank.deleted */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["BlankDeletedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "blank.drifted": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** blank.drifted */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["BlankDriftedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "blank.restored": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** blank.restored */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["BlankRestoredEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "blank.updated": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** blank.updated */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["BlankUpdatedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "credits.low": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** credits.low */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["CreditsLowEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "design.approval_scheduled": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** design.approval_scheduled */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["DesignApprovalScheduledEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "design.approved": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** design.approved */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["DesignApprovedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "design.changes_requested": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** design.changes_requested */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["DesignChangesRequestedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "design.committed": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** design.committed */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["DesignCommittedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "design.deleted": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** design.deleted */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["DesignDeletedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "design.delivery_captured": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** design.delivery_captured */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["DesignDeliveryCapturedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "design.duplicated": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** design.duplicated */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["DesignDuplicatedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "design.edited": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** design.edited */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["DesignEditedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "design.personal_data_erased": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** design.personal_data_erased */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["DesignPersonalDataErasedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "design.rejected": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** design.rejected */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["DesignRejectedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "ink.created": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** ink.created */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["InkCreatedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "ink.deleted": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** ink.deleted */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["InkDeletedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "ink.updated": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** ink.updated */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["InkUpdatedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "order.cancelled": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** order.cancelled */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["OrderCancelledEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "order.created": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** order.created */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["OrderCreatedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "order.delivery_changed": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** order.delivery_changed */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["OrderDeliveryChangedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "order.failed": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** order.failed */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["OrderFailedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "order.held": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** order.held */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["OrderHeldEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "order.released": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** order.released */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["OrderReleasedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "order.rerouted": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** order.rerouted */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["OrderReroutedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "order.status_changed": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** order.status_changed */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["OrderStatusChangedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "order.submitted": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** order.submitted */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["OrderSubmittedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "order.tracking_added": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** order.tracking_added */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["OrderTrackingAddedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "order.tracking_changed": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** order.tracking_changed */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["OrderTrackingChangedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "order_balance.empty": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** order_balance.empty */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["OrderBalanceEmptyEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "palette.created": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** palette.created */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["PaletteCreatedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "palette.deleted": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** palette.deleted */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["PaletteDeletedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "palette.updated": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** palette.updated */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["PaletteUpdatedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "print.completed": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** print.completed */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["PrintCompletedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "print.created": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** print.created */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["PrintCreatedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "print.failed": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** print.failed */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["PrintFailedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "printshop.connected": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** printshop.connected */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["PrintshopConnectedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "printshop.deleted": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** printshop.deleted */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["PrintshopDeletedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "printshop.disconnected": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** printshop.disconnected */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["PrintshopDisconnectedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "printshop.reconnected": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** printshop.reconnected */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["PrintshopReconnectedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "printshop.restored": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** printshop.restored */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["PrintshopRestoredEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "printshop.updated": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** printshop.updated */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["PrintshopUpdatedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "run.cancelled": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** run.cancelled */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["RunCancelledEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "run.completed": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** run.completed */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["RunCompletedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "run.exhausted": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** run.exhausted */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["RunExhaustedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "run.failed": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** run.failed */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["RunFailedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "run.started": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** run.started */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["RunStartedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "shape.created": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** shape.created */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["ShapeCreatedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "shape.deleted": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** shape.deleted */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["ShapeDeletedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "shape.updated": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** shape.updated */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["ShapeUpdatedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "share_link.regenerated": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** share_link.regenerated */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["ShareLinkRegeneratedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "share_link.revoked": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** share_link.revoked */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["ShareLinkRevokedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "template.deleted": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** template.deleted */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["TemplateDeletedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "template.live_changed": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * template.live_changed
         * @description A template was paused or resumed: `live: false` is a pause, after which customers cannot design on it, and `live: true` a resume. Sent once per template that flipped, whether one template or several were switched, and never for a switch to the state it already had. A store that missed a delivery, or connected after the switch, reads `status` on `GET /v1/templates/{id}`, which is the state to trust.
         */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["TemplateLiveChangedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "template.published": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** template.published */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["TemplatePublishedEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "text_messages.low": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** text_messages.low */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["TextMessagesLowEvent"];
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "webhook.ping": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * webhook.ping
         * @description A test request, sent on demand to one endpoint (`POST /v1/webhooks/{id}/ping`). Signed like a delivery, but never retried, never in the delivery log, and not a type an endpoint can subscribe to.
         */
        post: {
            parameters: {
                query?: never;
                header: {
                    /** @description When this attempt was sent, in Unix seconds. */
                    "x-pixonaut-timestamp": string;
                    /** @description `v1=` followed by the hex HMAC-SHA256, keyed with the endpoint's signing secret, of the `x-pixonaut-timestamp` value, a `.`, and the raw request body. */
                    "x-pixonaut-signature": string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": {
                        /** @description The automation that caused the event, beside `via`. */
                        automation?: {
                            /** @description The automation's id. */
                            id: string;
                            /** @description What the automation was called when it acted. */
                            name: string;
                        };
                        /** @description When the event happened, in milliseconds since the Unix epoch. */
                        createdAt: number;
                        /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
                        id: string;
                        payload: {
                            /** @description The webhook endpoint the ping tests. */
                            endpointId: string;
                        };
                        /** @enum {string} */
                        type: "webhook.ping";
                        /** @description `automation` when one of your automations caused the event; absent otherwise. */
                        via?: string;
                    };
                };
            };
            responses: {
                /** @description Any 2xx acknowledges the delivery. */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
}
export interface components {
    schemas: {
        AssetCreatedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                assetId: string;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "asset.created";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        AssetDeletedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                assetId: string;
                assetName: string | null;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "asset.deleted";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        AssetUpdatedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                assetId: string;
                fields: string[];
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "asset.updated";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        BlankCreatedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                blankId: string;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "blank.created";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        BlankDeletedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                blankId: string;
                blankName: string;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "blank.deleted";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        BlankDriftedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                blankId: string;
                blankName: string;
                kinds: string[];
                severity: string;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "blank.drifted";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        BlankRestoredEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                blankId: string;
                blankName: string;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "blank.restored";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        BlankUpdatedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                blankId: string;
                fields: string[];
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "blank.updated";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        CreditsLowEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                balanceCredits: number;
                grantCount: number;
                thresholdCredits: number;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "credits.low";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        DesignApprovalScheduledEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                approveAfter: number;
                designId: string;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "design.approval_scheduled";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        DesignApprovedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                approvedVia: string;
                /** @description How the customer agreed, as the design read's `approval_consent` keeps it: null when none was given. Absent only on an event recorded before approvals carried it. */
                consent?: {
                    /** @description When the customer agreed, epoch milliseconds. */
                    at: number;
                    /** @description How the customer agreed: by adding the design to their cart, by ticking a box, on a proof page, by approving it again on your store after correcting it (`edit`), or by letting your store's own approval deadline pass (`deadline`). More kinds may be added. */
                    kind: string;
                    ref: string | null;
                } | null;
                designId: string;
                /** @description The design's revision the decision was made about, as the design read's `revision` says it. Absent only on an event recorded before decisions carried it. */
                revision?: number;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "design.approved";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        DesignChangesRequestedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                designId: string;
                message: string;
                revision: number;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "design.changes_requested";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        DesignCommittedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                apiKeyId: string | null;
                designId: string;
                /** @description Where the design came from: the door it was committed through. A duplicate's is whoever duplicated it. */
                origin?: {
                    /** @description The designer link's id, the key's id, or the connected store's site address. Null for `studio`, and for a key set in the deployment's configuration rather than made in the workspace. */
                    id: string | null;
                    /** @description `link`: a designer link's page made it. `studio`: a member made it, in the studio or through an MCP key. `secret_key` and `publishable_key`: committed with one of your keys. `store`: committed by a connected store, with any key its site was given. */
                    kind: string;
                };
                shareLinkId?: string | null;
                templateId: string;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "design.committed";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        DesignDeletedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                designId: string;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "design.deleted";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        DesignDeliveryCapturedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                designId: string;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "design.delivery_captured";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        DesignDuplicatedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                designId: string;
                sourceDesignId: string;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "design.duplicated";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        DesignEditedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                designId: string;
                restoredFrom?: number;
                revision: number;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "design.edited";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        DesignPersonalDataErasedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                designId: string;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "design.personal_data_erased";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        DesignRejectedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                designId: string;
                /** @description Why the design was rejected, as its decider said, or null when they said nothing. Absent only on an event recorded before rejections carried it. */
                reason?: string | null;
                /** @description The design's revision the decision was made about, as the design read's `revision` says it. Absent only on an event recorded before decisions carried it. */
                revision?: number;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "design.rejected";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        InkCreatedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                inkId: string;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "ink.created";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        InkDeletedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                inkId: string;
                inkName: string;
                unlinked?: string[];
                unlinkedPalettes?: string[];
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "ink.deleted";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        InkUpdatedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                fields: string[];
                inkId: string;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "ink.updated";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        OrderBalanceEmptyEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                additionCount: number;
                heldOrders: number;
                topUp: string;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "order_balance.empty";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        OrderCancelledEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                automation?: {
                    id: string;
                    name: string;
                };
                externalRef?: string | null;
                orderId: string;
                printId: string;
                printIds?: string[];
                via?: string;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "order.cancelled";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        OrderCreatedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                adapter: string;
                externalRef: string | null;
                orderId: string;
                printId: string;
                printIds: string[];
                quantity: number;
                replacesOrderId: string | null;
                status: string;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "order.created";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        OrderDeliveryChangedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                added: boolean;
                by: string;
                externalRef?: string | null;
                orderId: string;
                outcome: string;
                printId: string;
                printIds?: string[];
                words: string | null;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "order.delivery_changed";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        OrderFailedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                automation?: {
                    id: string;
                    name: string;
                };
                externalRef?: string | null;
                kind?: string;
                orderId: string;
                printId: string;
                printIds?: string[];
                reason: string;
                via?: string;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "order.failed";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        OrderHeldEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                externalRef?: string | null;
                limit: number;
                orderId: string;
                periodEnd: string;
                printId: string;
                printIds?: string[];
                reason: string;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "order.held";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        OrderReleasedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                externalRef?: string | null;
                orderId: string;
                printId: string;
                printIds?: string[];
                releasedBy: string;
                status: string;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "order.released";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        OrderReroutedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                externalRef?: string | null;
                from: {
                    blankId: string | null;
                    printshopConnectionId: string | null;
                    variantRef: string | null;
                };
                orderId: string;
                printId: string;
                printIds?: string[];
                replacedOrderId: string;
                to: {
                    blankId: string | null;
                    printshopConnectionId: string | null;
                    variantRef: string | null;
                };
                via: string | null;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "order.rerouted";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        OrderStatusChangedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                automation?: {
                    id: string;
                    name: string;
                };
                externalRef?: string | null;
                orderId: string;
                previousStatus: string;
                printId: string;
                printIds?: string[];
                status: string;
                tracking?: {
                    /** @description Who carries it, such as `DHL`. */
                    carrier?: string;
                    /** @description The shipment's tracking number. */
                    number: string;
                    /**
                     * Format: uri
                     * @description Where the shipment is followed: an https address.
                     */
                    url?: string;
                };
                via?: string;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "order.status_changed";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        OrderSubmittedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                adapter: string;
                externalOrderRef: string | null;
                externalRef?: string | null;
                orderId: string;
                printId: string;
                printIds?: string[];
                quantity?: number;
                replacesOrderId?: string | null;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "order.submitted";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        OrderTrackingAddedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                externalRef: string | null;
                orderId: string;
                printId: string;
                printIds: string[];
                tracking: {
                    /** @description Who carries it, such as `DHL`. */
                    carrier?: string;
                    /** @description The shipment's tracking number. */
                    number: string;
                    /**
                     * Format: uri
                     * @description Where the shipment is followed: an https address.
                     */
                    url?: string;
                };
                via: string;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "order.tracking_added";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        OrderTrackingChangedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                externalRef: string | null;
                orderId: string;
                previousTracking: {
                    /** @description Who carries it, such as `DHL`. */
                    carrier?: string;
                    /** @description The shipment's tracking number. */
                    number: string;
                    /**
                     * Format: uri
                     * @description Where the shipment is followed: an https address.
                     */
                    url?: string;
                };
                printId: string;
                printIds: string[];
                tracking: {
                    /** @description Who carries it, such as `DHL`. */
                    carrier?: string;
                    /** @description The shipment's tracking number. */
                    number: string;
                    /**
                     * Format: uri
                     * @description Where the shipment is followed: an https address.
                     */
                    url?: string;
                };
                via: string;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "order.tracking_changed";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        PaletteCreatedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                paletteId: string;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "palette.created";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        PaletteDeletedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                paletteId: string;
                paletteName: string;
                unlinked?: string[];
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "palette.deleted";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        PaletteUpdatedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                fields: string[];
                paletteId: string;
                unlinked?: string[];
                uses?: string;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "palette.updated";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        PrintCompletedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                printId: string;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "print.completed";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        PrintCreatedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                designId: string;
                /** @default 1 */
                designRevision: number;
                printId: string;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "print.created";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        PrintFailedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                printId: string;
                reason: string;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "print.failed";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        PrintshopConnectedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                adapter: string;
                connectionId: string;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "printshop.connected";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        PrintshopDeletedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                adapter: string;
                connectionId: string;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "printshop.deleted";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        PrintshopDisconnectedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                adapter: string;
                connectionId: string;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "printshop.disconnected";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        PrintshopReconnectedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                adapter: string;
                connectionId: string;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "printshop.reconnected";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        PrintshopRestoredEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                adapter: string;
                connectionId: string;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "printshop.restored";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        PrintshopUpdatedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                adapter: string;
                connectionId: string;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "printshop.updated";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        ResolvedTemplate: {
            /** @description What is painted behind every layer, across the bleed. Absent is none. */
            background?: {
                /** @description The background colour. */
                color: {
                    /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                    constraints?: {
                        /**
                         * @description true lets a customer choose any colour, beside or instead of a palette.
                         * @enum {boolean}
                         */
                        anyColor: true;
                        /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                        oneOf?: string[];
                        /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                        palette: string;
                    } | {
                        /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                        oneOf?: string[];
                        /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                        palette?: string;
                    } | {
                        /**
                         * @description true lets a customer choose any colour, beside or instead of a palette.
                         * @enum {boolean}
                         */
                        anyColor: true;
                        /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                        oneOf?: string[];
                    };
                    /** @description A hint shown to the customer under the attribute's field. */
                    description?: string;
                    /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                    editable: boolean;
                    /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                    fieldKey?: string;
                    /** @description What a customer reads the attribute as, when editable. */
                    label?: string;
                    /** @description The attribute's value, as the template stores it. */
                    value: {
                        /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                        cmyk: [
                            number,
                            number,
                            number,
                            number
                        ];
                    } | {
                        /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                        spot: {
                            /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                            fallback: {
                                /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                cmyk: [
                                    number,
                                    number,
                                    number,
                                    number
                                ];
                            };
                            /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                            name: string;
                            /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                            preview?: {
                                /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                rgb: [
                                    number,
                                    number,
                                    number
                                ];
                            };
                        };
                    } | {
                        /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                        ink: string;
                    } | {
                        /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                        entry: string;
                        /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                        palette: string;
                    };
                };
                /**
                 * @description color paints the whole artwork, bleed included; image fills it with a picture.
                 * @enum {string}
                 */
                kind: "color";
            } | {
                /** @description Where the picture sits in its frame, under cover. Absent is uncropped. */
                crop?: {
                    /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                    constraints?: {
                        /** @description The most zoom a customer may choose; absent is 3. */
                        maxZoom?: number;
                        /** @description The least zoom a customer may choose; absent is 1. */
                        minZoom?: number;
                    };
                    /** @description A hint shown to the customer under the attribute's field. */
                    description?: string;
                    /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                    editable: boolean;
                    /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                    fieldKey?: string;
                    /** @description What a customer reads the attribute as, when editable. */
                    label?: string;
                    /** @description The attribute's value, as the template stores it. */
                    value: {
                        /** @description How far the picture's centre sits right of the frame's centre, in frame widths: 0.1 is a tenth of the frame. Clamped so the picture always covers the frame, never refused. */
                        xFrac: number;
                        /** @description How far the picture's centre sits below the frame's centre, in frame heights: 0.1 is a tenth of the frame. Clamped so the picture always covers the frame, never refused. */
                        yFrac: number;
                        /** @description The picture's scale over what cover gives it: 1 is the picture just covering the frame, up to 5. */
                        zoom: number;
                    };
                };
                /** @description How the picture fills its box: cover crops, contain shows it whole, fill stretches, tile repeats it. Absent is cover. */
                fit?: {
                    /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                    constraints?: {
                        /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                        oneOf?: string[];
                    };
                    /** @description A hint shown to the customer under the attribute's field. */
                    description?: string;
                    /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                    editable: boolean;
                    /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                    fieldKey?: string;
                    /** @description What a customer reads the attribute as, when editable. */
                    label?: string;
                    /** @description The attribute's value, as the template stores it. */
                    value: string;
                };
                /** @description The background picture's asset id. */
                imageAssetId: {
                    /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                    constraints?: {
                        /** @description Whether a customer may upload a picture of their own. */
                        allowUpload?: boolean;
                        /**
                         * @description true cuts a customer's upload out onto a transparent background, as a new upload in its place paid from the tenant's credits; one that fails leaves their photo as it was. Absent, never.
                         * @enum {boolean}
                         */
                        cutOut?: true;
                        /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                        oneOf?: string[];
                        /** @description Whether a customer must change the template's default (a placeholder name or photo) before a design is accepted. Only on an offered text's content, image's picture, or shape's outline or fill. */
                        requireChange?: boolean;
                        /** @description Whether a customer must choose a picture. */
                        required?: boolean;
                        /** @description Present, an upload below `belowDpi` at the customer's chosen size is offered an upscale to `toDpi` before the proof, paid from the tenant's credits. Absent, never. */
                        upscale?: {
                            /** @description The print resolution, in dots per inch, below which an upload is offered an upscale. Absent, the template's minimum, else the tenant's. */
                            belowDpi?: number;
                            /** @description The print resolution, in dots per inch, an upload is upscaled to, and priced by: under `belowDpi`, at it or past it. Absent, `belowDpi`. */
                            toDpi?: number;
                        };
                    };
                    /** @description A hint shown to the customer under the attribute's field. */
                    description?: string;
                    /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                    editable: boolean;
                    /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                    fieldKey?: string;
                    /** @description What a customer reads the attribute as, when editable. */
                    label?: string;
                    /** @description The attribute's value, as the template stores it. */
                    value: string;
                };
                /**
                 * @description color paints the whole artwork, bleed included; image fills it with a picture.
                 * @enum {string}
                 */
                kind: "image";
                /** @description The tile's size against the picture's own, when the fit is tile. */
                tileScale?: {
                    /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                    constraints?: {
                        /** @description The largest tile scale a customer may choose. */
                        max?: number;
                        /** @description The smallest tile scale a customer may choose. */
                        min?: number;
                        /** @description The step between the tile scales a customer may choose. */
                        step?: number;
                    };
                    /** @description A hint shown to the customer under the attribute's field. */
                    description?: string;
                    /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                    editable: boolean;
                    /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                    fieldKey?: string;
                    /** @description What a customer reads the attribute as, when editable. */
                    label?: string;
                    /** @description The attribute's value, as the template stores it. */
                    value: number;
                };
            };
            /** @description Which of nine points, top-left to bottom-right, a cover crop keeps; read only when fit is cover. Absent is center. */
            coverAlign?: string;
            /** @description The layers a customer may add of their own, per kind: how many, and the preset each starts as. Added layers paint above the template's layers and belong to no group. */
            customerLayers?: {
                /** @description Whether, and how, a customer may add image layers. */
                image?: {
                    /** @description The preset every added image layer starts as: a image layer without id, name, z, anchorTo, locked or print. What it offers is what a customer may change on the layers they add. */
                    layer: {
                        /** @description The point of the reference the layer is placed against, and the layer's own matching point: top-left puts the layer's top-left corner on the reference's. */
                        anchor: string;
                        /** @description How it mixes with the layers under it, per ink. Absent is normal. */
                        blend?: string;
                        /** @description The layer's height as a fraction of the reference's height. Positive; uncapped, so above 1 hangs over the edge and is clipped. */
                        hFrac: number;
                        /** @description A backdrop painted behind this layer's content at exactly its box: a colour, or a filled shape. Text and image layers only. */
                        mat?: {
                            /** @description The backdrop's colour. */
                            color: {
                                /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                cmyk: [
                                    number,
                                    number,
                                    number,
                                    number
                                ];
                            } | {
                                /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                                spot: {
                                    /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                    fallback: {
                                        /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                        cmyk: [
                                            number,
                                            number,
                                            number,
                                            number
                                        ];
                                    };
                                    /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                    name: string;
                                    /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                    preview?: {
                                        /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                        rgb: [
                                            number,
                                            number,
                                            number
                                        ];
                                    };
                                };
                            } | {
                                /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                ink: string;
                            } | {
                                /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                                entry: string;
                                /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                                palette: string;
                            };
                            /**
                             * @description color is a plain backdrop; shape fills a silhouette.
                             * @enum {string}
                             */
                            kind: "color";
                        } | {
                            /** @description The silhouette's colour. */
                            fill: {
                                /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                cmyk: [
                                    number,
                                    number,
                                    number,
                                    number
                                ];
                            } | {
                                /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                                spot: {
                                    /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                    fallback: {
                                        /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                        cmyk: [
                                            number,
                                            number,
                                            number,
                                            number
                                        ];
                                    };
                                    /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                    name: string;
                                    /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                    preview?: {
                                        /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                        rgb: [
                                            number,
                                            number,
                                            number
                                        ];
                                    };
                                };
                            } | {
                                /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                ink: string;
                            } | {
                                /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                                entry: string;
                                /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                                palette: string;
                            };
                            /**
                             * @description color is a plain backdrop; shape fills a silhouette.
                             * @enum {string}
                             */
                            kind: "shape";
                            /** @description The backdrop's silhouette, at the layer's box. */
                            shape: {
                                /** @description SVG path data in fractions of its box, (0,0) its top-left and (1,1) its bottom-right: `M 0 0 L 1 0 L 1 1 L 0 1 Z` is the whole box. No arcs. */
                                dFrac: string;
                                /**
                                 * @description Inline path geometry.
                                 * @enum {string}
                                 */
                                type: "path";
                            } | {
                                /** @description The shape's id, `shp_…`, as list_shapes returns it. */
                                shapeId: string;
                                /**
                                 * @description One of the tenant's shapes, by id.
                                 * @enum {string}
                                 */
                                type: "shape";
                            };
                        };
                        /** @description How far the layer sits from its anchor, as fractions of the reference, always toward the reference's centre: { x: 0.05, y: 0.05 } nudges it 5 % in from any corner. Ignored on a centred axis. */
                        offsetFrac: {
                            /** @description Across, as a fraction of the reference's width: 0.05 is 5 %. Toward the centre; negative pushes outward. Uncapped. */
                            x: number;
                            /** @description Down or up, as a fraction of the reference's height: 0.05 is 5 %. Toward the centre; negative pushes outward. Uncapped. */
                            y: number;
                        };
                        /** @description The layer's opacity, which a customer may be offered. Absent is full and not offered. */
                        opacity?: {
                            /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                            constraints?: {
                                /** @description The most opacity a customer may choose, 0.01 to 1. */
                                max?: number;
                                /** @description The least opacity a customer may choose, 0.01 to 1. */
                                min?: number;
                                /** @description The step between choosable opacities, e.g. 0.05. */
                                step?: number;
                            };
                            /** @description A hint shown to the customer under the attribute's field. */
                            description?: string;
                            /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                            editable: boolean;
                            /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                            fieldKey?: string;
                            /** @description What a customer reads the attribute as, when editable. */
                            label?: string;
                            /** @description How opaque the whole layer is: 1 is full, 0.01 the least. */
                            value: number;
                        };
                        props: {
                            /** @description How much lighter (up to 1) or darker (down to -1) the photo is drawn; absent or 0 is as uploaded. */
                            brightness?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most value a customer may choose. */
                                    max?: number;
                                    /** @description The least value a customer may choose. */
                                    min?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The step between the values a customer may choose. */
                                    step?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: number;
                            };
                            /** @description How far the photo's tones are pushed apart (up to 1) or pulled toward middle grey (down to -1); absent or 0 is as uploaded. */
                            contrast?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most value a customer may choose. */
                                    max?: number;
                                    /** @description The least value a customer may choose. */
                                    min?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The step between the values a customer may choose. */
                                    step?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: number;
                            };
                            /** @description How round the picture's corners are: their radius as a fraction of the shorter side of the layer's box, 0 (square) to 0.5 (a square box becomes a circle). The outline and the shadow follow it. */
                            cornerRadiusShortSide?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most value a customer may choose. */
                                    max?: number;
                                    /** @description The least value a customer may choose. */
                                    min?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The step between the values a customer may choose. */
                                    step?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: number;
                            };
                            /** @description Where the picture sits in its frame, under cover. Absent is uncropped. */
                            crop?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most zoom a customer may choose; absent is 3. */
                                    maxZoom?: number;
                                    /** @description The least zoom a customer may choose; absent is 1. */
                                    minZoom?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: {
                                    /** @description How far the picture's centre sits right of the frame's centre, in frame widths: 0.1 is a tenth of the frame. Clamped so the picture always covers the frame, never refused. */
                                    xFrac: number;
                                    /** @description How far the picture's centre sits below the frame's centre, in frame heights: 0.1 is a tenth of the frame. Clamped so the picture always covers the frame, never refused. */
                                    yFrac: number;
                                    /** @description The picture's scale over what cover gives it: 1 is the picture just covering the frame, up to 5. */
                                    zoom: number;
                                };
                            };
                            /** @description The colour a duotone photo's lightest tones become; absent is paper white. A process colour: a spot ink is refused. */
                            duotoneHighlight?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /**
                                     * @description true lets a customer choose any colour, beside or instead of a palette.
                                     * @enum {boolean}
                                     */
                                    anyColor: true;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                                    palette: string;
                                } | {
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                                    palette?: string;
                                } | {
                                    /**
                                     * @description true lets a customer choose any colour, beside or instead of a palette.
                                     * @enum {boolean}
                                     */
                                    anyColor: true;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: {
                                    /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                    cmyk: [
                                        number,
                                        number,
                                        number,
                                        number
                                    ];
                                } | {
                                    /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                                    spot: {
                                        /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                        fallback: {
                                            /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                            cmyk: [
                                                number,
                                                number,
                                                number,
                                                number
                                            ];
                                        };
                                        /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                        name: string;
                                        /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                        preview?: {
                                            /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                            rgb: [
                                                number,
                                                number,
                                                number
                                            ];
                                        };
                                    };
                                } | {
                                    /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                    ink: string;
                                } | {
                                    /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                                    entry: string;
                                    /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                                    palette: string;
                                };
                            };
                            /** @description The colour a duotone photo's darkest tones become; absent is black. A process colour: a spot ink is refused. */
                            duotoneShadow?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /**
                                     * @description true lets a customer choose any colour, beside or instead of a palette.
                                     * @enum {boolean}
                                     */
                                    anyColor: true;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                                    palette: string;
                                } | {
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                                    palette?: string;
                                } | {
                                    /**
                                     * @description true lets a customer choose any colour, beside or instead of a palette.
                                     * @enum {boolean}
                                     */
                                    anyColor: true;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: {
                                    /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                    cmyk: [
                                        number,
                                        number,
                                        number,
                                        number
                                    ];
                                } | {
                                    /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                                    spot: {
                                        /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                        fallback: {
                                            /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                            cmyk: [
                                                number,
                                                number,
                                                number,
                                                number
                                            ];
                                        };
                                        /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                        name: string;
                                        /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                        preview?: {
                                            /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                            rgb: [
                                                number,
                                                number,
                                                number
                                            ];
                                        };
                                    };
                                } | {
                                    /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                    ink: string;
                                } | {
                                    /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                                    entry: string;
                                    /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                                    palette: string;
                                };
                            };
                            /** @description What the outline and the shadow are cast from: box (the layer's box, rounded by its corners) or picture (the picture's own visible pixels, so a cut-out casts its own shape). An image with a colour mat follows its box. Absent is box. */
                            effectsFollow?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: string;
                            };
                            /** @description How the picture fills its box: cover crops, contain shows it whole, fill stretches, tile repeats it. Absent is cover. */
                            fit: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: string;
                            };
                            /** @description The colour of the image's outline, whichever width draws it: absent is black under outlineWidthShortSide, and white, a sticker's edge, under outlineWidthShare. */
                            outlineColor?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /**
                                     * @description true lets a customer choose any colour, beside or instead of a palette.
                                     * @enum {boolean}
                                     */
                                    anyColor: true;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                                    palette: string;
                                } | {
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                                    palette?: string;
                                } | {
                                    /**
                                     * @description true lets a customer choose any colour, beside or instead of a palette.
                                     * @enum {boolean}
                                     */
                                    anyColor: true;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: {
                                    /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                    cmyk: [
                                        number,
                                        number,
                                        number,
                                        number
                                    ];
                                } | {
                                    /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                                    spot: {
                                        /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                        fallback: {
                                            /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                            cmyk: [
                                                number,
                                                number,
                                                number,
                                                number
                                            ];
                                        };
                                        /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                        name: string;
                                        /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                        preview?: {
                                            /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                            rgb: [
                                                number,
                                                number,
                                                number
                                            ];
                                        };
                                    };
                                } | {
                                    /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                    ink: string;
                                } | {
                                    /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                                    entry: string;
                                    /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                                    palette: string;
                                };
                            };
                            /** @description The width of an outline drawn round the picture's own pixels, like a sticker's edge, as a fraction of the picture box's shorter side (0.02 is a fiftieth of it), 0 to 0.1; absent or 0 draws no outline. Not drawn on a tiled picture. An image sets this or outlineWidthShortSide, never both. */
                            outlineWidthShare?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most value a customer may choose. */
                                    max?: number;
                                    /** @description The least value a customer may choose. */
                                    min?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The step between the values a customer may choose. */
                                    step?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: number;
                            };
                            /** @description The outline's width as a fraction of the shorter side of the layer's box (0.02 is a fiftieth of it), 0 to 0.1; absent or 0 draws no outline. On an image, traced round its box or its picture (effectsFollow); an image sets this or outlineWidthShare, never both. */
                            outlineWidthShortSide?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most value a customer may choose. */
                                    max?: number;
                                    /** @description The least value a customer may choose. */
                                    min?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The step between the values a customer may choose. */
                                    step?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: number;
                            };
                            /** @description How far the photo's colours are strengthened (up to 1) or pulled toward grey (down to -1); absent or 0 is as uploaded. A tone other than none draws no colour of the photo's own, so saturation then changes nothing. */
                            saturation?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most value a customer may choose. */
                                    max?: number;
                                    /** @description The least value a customer may choose. */
                                    min?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The step between the values a customer may choose. */
                                    step?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: number;
                            };
                            /** @description How soft the shadow is: its blur radius as a fraction of the shorter side of the layer's box, 0 (sharp) to 0.25. A shadow with no offset and no blur draws nothing. */
                            shadowBlurShortSide?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most value a customer may choose. */
                                    max?: number;
                                    /** @description The least value a customer may choose. */
                                    min?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The step between the values a customer may choose. */
                                    step?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: number;
                            };
                            /** @description The colour of the shadow drawn under the layer; absent is black. */
                            shadowColor?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /**
                                     * @description true lets a customer choose any colour, beside or instead of a palette.
                                     * @enum {boolean}
                                     */
                                    anyColor: true;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                                    palette: string;
                                } | {
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                                    palette?: string;
                                } | {
                                    /**
                                     * @description true lets a customer choose any colour, beside or instead of a palette.
                                     * @enum {boolean}
                                     */
                                    anyColor: true;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: {
                                    /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                    cmyk: [
                                        number,
                                        number,
                                        number,
                                        number
                                    ];
                                } | {
                                    /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                                    spot: {
                                        /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                        fallback: {
                                            /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                            cmyk: [
                                                number,
                                                number,
                                                number,
                                                number
                                            ];
                                        };
                                        /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                        name: string;
                                        /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                        preview?: {
                                            /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                            rgb: [
                                                number,
                                                number,
                                                number
                                            ];
                                        };
                                    };
                                } | {
                                    /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                    ink: string;
                                } | {
                                    /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                                    entry: string;
                                    /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                                    palette: string;
                                };
                            };
                            /** @description How far right the shadow falls, as a fraction of the shorter side of the layer's box, -0.25 to 0.25; negative is left. */
                            shadowOffsetXShortSide?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most value a customer may choose. */
                                    max?: number;
                                    /** @description The least value a customer may choose. */
                                    min?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The step between the values a customer may choose. */
                                    step?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: number;
                            };
                            /** @description How far down the shadow falls, as a fraction of the shorter side of the layer's box, -0.25 to 0.25; negative is up. */
                            shadowOffsetYShortSide?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most value a customer may choose. */
                                    max?: number;
                                    /** @description The least value a customer may choose. */
                                    min?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The step between the values a customer may choose. */
                                    step?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: number;
                            };
                            /** @description The picture's asset id; null is none chosen yet. */
                            src: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description Whether a customer may upload a picture of their own. */
                                    allowUpload?: boolean;
                                    /**
                                     * @description true cuts a customer's upload out onto a transparent background, as a new upload in its place paid from the tenant's credits; one that fails leaves their photo as it was. Absent, never.
                                     * @enum {boolean}
                                     */
                                    cutOut?: true;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description Whether a customer must change the template's default (a placeholder name or photo) before a design is accepted. Only on an offered text's content, image's picture, or shape's outline or fill. */
                                    requireChange?: boolean;
                                    /** @description Whether a customer must choose a picture. */
                                    required?: boolean;
                                    /** @description Present, an upload below `belowDpi` at the customer's chosen size is offered an upscale to `toDpi` before the proof, paid from the tenant's credits. Absent, never. */
                                    upscale?: {
                                        /** @description The print resolution, in dots per inch, below which an upload is offered an upscale. Absent, the template's minimum, else the tenant's. */
                                        belowDpi?: number;
                                        /** @description The print resolution, in dots per inch, an upload is upscaled to, and priced by: under `belowDpi`, at it or past it. Absent, `belowDpi`. */
                                        toDpi?: number;
                                    };
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: string | null;
                            };
                            /** @description The tile's size against the picture's own, when the fit is tile. */
                            tileScale?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The largest tile scale a customer may choose. */
                                    max?: number;
                                    /** @description The smallest tile scale a customer may choose. */
                                    min?: number;
                                    /** @description The step between the tile scales a customer may choose. */
                                    step?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: number;
                            };
                            /** @description What the photo's lightness is mapped onto, after brightness, contrast and saturation: none (its own colours), blackAndWhite, sepia, or duotone (from duotoneShadow in its darkest tones to duotoneHighlight in its lightest). Absent is none. */
                            tone?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: string;
                            };
                        };
                        /** @description The layer's rotation, scale and flip, and which of them, and its position, a customer may change. */
                        transform: {
                            /** @description Whether a customer may flip the layer. */
                            flip?: {
                                /** @description A hint shown to the customer under the control. */
                                description?: string;
                                /** @description Whether a customer may change it. */
                                editable: boolean;
                                /** @description What a customer reads the control as. */
                                label?: string;
                            };
                            /** @description Whether, and within what, a customer may resize the layer. */
                            resize?: {
                                /** @description A hint shown to the customer under the control. */
                                description?: string;
                                /** @description Whether a customer may change it. */
                                editable?: boolean;
                                /** @description What a customer reads the control as. */
                                label?: string;
                                /** @description The most height, in millimetres. */
                                maxHMm?: number;
                                /** @description The most width, in millimetres. */
                                maxWMm?: number;
                                /** @description The least height, in millimetres. */
                                minHMm?: number;
                                /** @description The least width, in millimetres. */
                                minWMm?: number;
                            };
                            /** @description Whether, and how far, a customer may rotate the layer. */
                            rotate: {
                                /** @description A hint shown to the customer under the control. */
                                description?: string;
                                /** @description Whether a customer may change it. */
                                editable: boolean;
                                /** @description What a customer reads the control as. */
                                label?: string;
                                /** @description The most rotation, in degrees. */
                                max?: number;
                                /** @description The least rotation, in degrees. */
                                min?: number;
                                /** @description The angle rotation snaps to, in degrees, e.g. 15. */
                                snapDeg?: number;
                            };
                            /** @description Whether, and how far, a customer may scale the layer. */
                            scale: {
                                /** @description A hint shown to the customer under the control. */
                                description?: string;
                                /** @description Whether a customer may change it. */
                                editable: boolean;
                                /** @description What a customer reads the control as. */
                                label?: string;
                                /** @description The most scale; 1 is as authored. */
                                max?: number;
                                /** @description The least scale; 1 is as authored. */
                                min?: number;
                                /** @description The step between the scales a customer may choose. */
                                step?: number;
                            };
                            /** @description Whether, and within what, a customer may move the layer. */
                            translate: {
                                /** @description Where a customer's move must keep the layer: inside the safe area (the default), the print box, or anywhere. */
                                bounds?: string;
                                /** @description A hint shown to the customer under the control. */
                                description?: string;
                                /** @description Whether a customer may change it. */
                                editable: boolean;
                                /** @description What a customer reads the control as. */
                                label?: string;
                                /** @description What a move snaps to: centre, thirds, safeEdges, layers. */
                                snapTo?: string[];
                            };
                            /** @description The layer's rotation, scale and flip. */
                            value: {
                                /** @description Whether the layer is mirrored left to right, about its centre and before its rotation. */
                                flipX?: boolean;
                                /** @description Whether the layer is mirrored top to bottom, about its centre and before its rotation. */
                                flipY?: boolean;
                                /** @description Rotation about the layer's anchor, in degrees, clockwise. */
                                rotationDeg: number;
                                /** @description Scale of the layer; 1 is as authored. */
                                scale: number;
                            };
                        };
                        type: string;
                        /**
                         * @description true lays spot varnish exactly where the layer is, on a machine that varnishes; it still prints in colour.
                         * @enum {boolean}
                         */
                        varnish?: true;
                        /** @description The layer's width as a fraction of the reference's width. Positive; uncapped, so above 1 hangs over the edge and is clipped. */
                        wFrac: number;
                    };
                    /** @description How many image layers a customer may add, 1 to 20. */
                    max: number;
                };
                /** @description Whether, and how, a customer may add shape layers. */
                shape?: {
                    /** @description The preset every added shape layer starts as: a shape layer without id, name, z, anchorTo, locked or print. What it offers is what a customer may change on the layers they add. */
                    layer: {
                        /** @description The point of the reference the layer is placed against, and the layer's own matching point: top-left puts the layer's top-left corner on the reference's. */
                        anchor: string;
                        /** @description How it mixes with the layers under it, per ink. Absent is normal. */
                        blend?: string;
                        /** @description The layer's height as a fraction of the reference's height. Positive; uncapped, so above 1 hangs over the edge and is clipped. */
                        hFrac: number;
                        /** @description How far the layer sits from its anchor, as fractions of the reference, always toward the reference's centre: { x: 0.05, y: 0.05 } nudges it 5 % in from any corner. Ignored on a centred axis. */
                        offsetFrac: {
                            /** @description Across, as a fraction of the reference's width: 0.05 is 5 %. Toward the centre; negative pushes outward. Uncapped. */
                            x: number;
                            /** @description Down or up, as a fraction of the reference's height: 0.05 is 5 %. Toward the centre; negative pushes outward. Uncapped. */
                            y: number;
                        };
                        /** @description The layer's opacity, which a customer may be offered. Absent is full and not offered. */
                        opacity?: {
                            /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                            constraints?: {
                                /** @description The most opacity a customer may choose, 0.01 to 1. */
                                max?: number;
                                /** @description The least opacity a customer may choose, 0.01 to 1. */
                                min?: number;
                                /** @description The step between choosable opacities, e.g. 0.05. */
                                step?: number;
                            };
                            /** @description A hint shown to the customer under the attribute's field. */
                            description?: string;
                            /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                            editable: boolean;
                            /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                            fieldKey?: string;
                            /** @description What a customer reads the attribute as, when editable. */
                            label?: string;
                            /** @description How opaque the whole layer is: 1 is full, 0.01 the least. */
                            value: number;
                        };
                        props: {
                            /** @description Where the picture sits in its frame, under cover. Absent is uncropped. */
                            crop?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most zoom a customer may choose; absent is 3. */
                                    maxZoom?: number;
                                    /** @description The least zoom a customer may choose; absent is 1. */
                                    minZoom?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: {
                                    /** @description How far the picture's centre sits right of the frame's centre, in frame widths: 0.1 is a tenth of the frame. Clamped so the picture always covers the frame, never refused. */
                                    xFrac: number;
                                    /** @description How far the picture's centre sits below the frame's centre, in frame heights: 0.1 is a tenth of the frame. Clamped so the picture always covers the frame, never refused. */
                                    yFrac: number;
                                    /** @description The picture's scale over what cover gives it: 1 is the picture just covering the frame, up to 5. */
                                    zoom: number;
                                };
                            };
                            /** @description What the silhouette is painted with: a colour, a gradient across its box, or a picture clipped to it. */
                            fill: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description Whether a customer may upload a picture of their own. */
                                    allowUpload?: boolean;
                                    /**
                                     * @description true lets a customer choose any colour, beside or instead of a palette.
                                     * @enum {boolean}
                                     */
                                    anyColor?: true;
                                    /**
                                     * @description true cuts a customer's upload out onto a transparent background, as a new upload in its place paid from the tenant's credits; one that fails leaves their photo as it was. Absent, never.
                                     * @enum {boolean}
                                     */
                                    cutOut?: true;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                                    palette?: string;
                                    /** @description Whether a customer must change the template's default (a placeholder name or photo) before a design is accepted. Only on an offered text's content, image's picture, or shape's outline or fill. */
                                    requireChange?: boolean;
                                    /** @description Whether a customer must choose a picture. */
                                    required?: boolean;
                                    /** @description Present, an upload below `belowDpi` at the customer's chosen size is offered an upscale to `toDpi` before the proof, paid from the tenant's credits. Absent, never. */
                                    upscale?: {
                                        /** @description The print resolution, in dots per inch, below which an upload is offered an upscale. Absent, the template's minimum, else the tenant's. */
                                        belowDpi?: number;
                                        /** @description The print resolution, in dots per inch, an upload is upscaled to, and priced by: under `belowDpi`, at it or past it. Absent, `belowDpi`. */
                                        toDpi?: number;
                                    };
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: {
                                    /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                    cmyk: [
                                        number,
                                        number,
                                        number,
                                        number
                                    ];
                                } | {
                                    /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                                    spot: {
                                        /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                        fallback: {
                                            /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                            cmyk: [
                                                number,
                                                number,
                                                number,
                                                number
                                            ];
                                        };
                                        /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                        name: string;
                                        /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                        preview?: {
                                            /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                            rgb: [
                                                number,
                                                number,
                                                number
                                            ];
                                        };
                                    };
                                } | {
                                    /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                    ink: string;
                                } | {
                                    /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                                    entry: string;
                                    /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                                    palette: string;
                                } | {
                                    /** @description linear crosses a shape's box or text's letters at an angle; radial from the centre to the farthest corner. */
                                    gradient: {
                                        /** @description The direction the colours run, in degrees clockwise from straight up: 90 runs left to right, 180 top to bottom. It spans a shape's box or a text's letters. */
                                        angleDeg: number;
                                        /** @enum {string} */
                                        kind: "linear";
                                        /** @description The gradient's colours, 2 to 8, in order of position. Blended in CMYK, as the print blends them. */
                                        stops: {
                                            /** @description Where the colour sits along the gradient: 0 is its start, 1 its end. Stops are in order; two at one position make a hard edge. */
                                            at: number;
                                            /** @description The colour at this stop: a CMYK colour, one of your inks, or a palette entry. A spot ink cannot be one: a gradient blends process colours. */
                                            color: {
                                                /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                                cmyk: [
                                                    number,
                                                    number,
                                                    number,
                                                    number
                                                ];
                                            } | {
                                                /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                                                spot: {
                                                    /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                                    fallback: {
                                                        /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                                        cmyk: [
                                                            number,
                                                            number,
                                                            number,
                                                            number
                                                        ];
                                                    };
                                                    /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                                    name: string;
                                                    /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                                    preview?: {
                                                        /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                                        rgb: [
                                                            number,
                                                            number,
                                                            number
                                                        ];
                                                    };
                                                };
                                            } | {
                                                /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                                ink: string;
                                            } | {
                                                /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                                                entry: string;
                                                /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                                                palette: string;
                                            };
                                        }[];
                                    } | {
                                        /** @enum {string} */
                                        kind: "radial";
                                        /** @description The gradient's colours, 2 to 8, in order of position. Blended in CMYK, as the print blends them. */
                                        stops: {
                                            /** @description Where the colour sits along the gradient: 0 is its start, 1 its end. Stops are in order; two at one position make a hard edge. */
                                            at: number;
                                            /** @description The colour at this stop: a CMYK colour, one of your inks, or a palette entry. A spot ink cannot be one: a gradient blends process colours. */
                                            color: {
                                                /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                                cmyk: [
                                                    number,
                                                    number,
                                                    number,
                                                    number
                                                ];
                                            } | {
                                                /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                                                spot: {
                                                    /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                                    fallback: {
                                                        /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                                        cmyk: [
                                                            number,
                                                            number,
                                                            number,
                                                            number
                                                        ];
                                                    };
                                                    /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                                    name: string;
                                                    /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                                    preview?: {
                                                        /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                                        rgb: [
                                                            number,
                                                            number,
                                                            number
                                                        ];
                                                    };
                                                };
                                            } | {
                                                /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                                ink: string;
                                            } | {
                                                /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                                                entry: string;
                                                /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                                                palette: string;
                                            };
                                        }[];
                                    };
                                } | {
                                    /** @description A picture's asset id, clipped to the shape; empty while none is chosen. */
                                    imageAssetId: string;
                                };
                            };
                            /** @description How the picture fills its box: cover crops, contain shows it whole, fill stretches, tile repeats it. Absent is cover. */
                            fit?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: string;
                            };
                            /** @description The colour of the line drawn around the layer's edge, outside it; absent is black. */
                            outlineColor?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /**
                                     * @description true lets a customer choose any colour, beside or instead of a palette.
                                     * @enum {boolean}
                                     */
                                    anyColor: true;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                                    palette: string;
                                } | {
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                                    palette?: string;
                                } | {
                                    /**
                                     * @description true lets a customer choose any colour, beside or instead of a palette.
                                     * @enum {boolean}
                                     */
                                    anyColor: true;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: {
                                    /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                    cmyk: [
                                        number,
                                        number,
                                        number,
                                        number
                                    ];
                                } | {
                                    /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                                    spot: {
                                        /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                        fallback: {
                                            /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                            cmyk: [
                                                number,
                                                number,
                                                number,
                                                number
                                            ];
                                        };
                                        /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                        name: string;
                                        /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                        preview?: {
                                            /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                            rgb: [
                                                number,
                                                number,
                                                number
                                            ];
                                        };
                                    };
                                } | {
                                    /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                    ink: string;
                                } | {
                                    /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                                    entry: string;
                                    /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                                    palette: string;
                                };
                            };
                            /** @description The outline's width as a fraction of the shorter side of the layer's box (0.02 is a fiftieth of it), 0 to 0.1; absent or 0 draws no outline. On an image, traced round its box or its picture (effectsFollow); an image sets this or outlineWidthShare, never both. */
                            outlineWidthShortSide?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most value a customer may choose. */
                                    max?: number;
                                    /** @description The least value a customer may choose. */
                                    min?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The step between the values a customer may choose. */
                                    step?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: number;
                            };
                            /** @description How soft the shadow is: its blur radius as a fraction of the shorter side of the layer's box, 0 (sharp) to 0.25. A shadow with no offset and no blur draws nothing. */
                            shadowBlurShortSide?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most value a customer may choose. */
                                    max?: number;
                                    /** @description The least value a customer may choose. */
                                    min?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The step between the values a customer may choose. */
                                    step?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: number;
                            };
                            /** @description The colour of the shadow drawn under the layer; absent is black. */
                            shadowColor?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /**
                                     * @description true lets a customer choose any colour, beside or instead of a palette.
                                     * @enum {boolean}
                                     */
                                    anyColor: true;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                                    palette: string;
                                } | {
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                                    palette?: string;
                                } | {
                                    /**
                                     * @description true lets a customer choose any colour, beside or instead of a palette.
                                     * @enum {boolean}
                                     */
                                    anyColor: true;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: {
                                    /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                    cmyk: [
                                        number,
                                        number,
                                        number,
                                        number
                                    ];
                                } | {
                                    /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                                    spot: {
                                        /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                        fallback: {
                                            /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                            cmyk: [
                                                number,
                                                number,
                                                number,
                                                number
                                            ];
                                        };
                                        /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                        name: string;
                                        /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                        preview?: {
                                            /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                            rgb: [
                                                number,
                                                number,
                                                number
                                            ];
                                        };
                                    };
                                } | {
                                    /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                    ink: string;
                                } | {
                                    /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                                    entry: string;
                                    /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                                    palette: string;
                                };
                            };
                            /** @description How far right the shadow falls, as a fraction of the shorter side of the layer's box, -0.25 to 0.25; negative is left. */
                            shadowOffsetXShortSide?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most value a customer may choose. */
                                    max?: number;
                                    /** @description The least value a customer may choose. */
                                    min?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The step between the values a customer may choose. */
                                    step?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: number;
                            };
                            /** @description How far down the shadow falls, as a fraction of the shorter side of the layer's box, -0.25 to 0.25; negative is up. */
                            shadowOffsetYShortSide?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most value a customer may choose. */
                                    max?: number;
                                    /** @description The least value a customer may choose. */
                                    min?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The step between the values a customer may choose. */
                                    step?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: number;
                            };
                            /** @description The layer's silhouette: inline geometry or one of the tenant's shapes. */
                            shape: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /**
                                     * @description true lets a customer choose no shape at all.
                                     * @enum {boolean}
                                     */
                                    allowEmpty?: true;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description Whether a customer must change the template's default (a placeholder name or photo) before a design is accepted. Only on an offered text's content, image's picture, or shape's outline or fill. */
                                    requireChange?: boolean;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: {
                                    /** @description SVG path data in fractions of its box, (0,0) its top-left and (1,1) its bottom-right: `M 0 0 L 1 0 L 1 1 L 0 1 Z` is the whole box. No arcs. */
                                    dFrac: string;
                                    /**
                                     * @description Inline path geometry.
                                     * @enum {string}
                                     */
                                    type: "path";
                                } | {
                                    /** @description The shape's id, `shp_…`, as list_shapes returns it. */
                                    shapeId: string;
                                    /**
                                     * @description One of the tenant's shapes, by id.
                                     * @enum {string}
                                     */
                                    type: "shape";
                                };
                            };
                            /** @description The tile's size against the picture's own, when the fit is tile. */
                            tileScale?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The largest tile scale a customer may choose. */
                                    max?: number;
                                    /** @description The smallest tile scale a customer may choose. */
                                    min?: number;
                                    /** @description The step between the tile scales a customer may choose. */
                                    step?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: number;
                            };
                        };
                        /** @description The layer's rotation, scale and flip, and which of them, and its position, a customer may change. */
                        transform: {
                            /** @description Whether a customer may flip the layer. */
                            flip?: {
                                /** @description A hint shown to the customer under the control. */
                                description?: string;
                                /** @description Whether a customer may change it. */
                                editable: boolean;
                                /** @description What a customer reads the control as. */
                                label?: string;
                            };
                            /** @description Whether, and within what, a customer may resize the layer. */
                            resize?: {
                                /** @description A hint shown to the customer under the control. */
                                description?: string;
                                /** @description Whether a customer may change it. */
                                editable?: boolean;
                                /** @description What a customer reads the control as. */
                                label?: string;
                                /** @description The most height, in millimetres. */
                                maxHMm?: number;
                                /** @description The most width, in millimetres. */
                                maxWMm?: number;
                                /** @description The least height, in millimetres. */
                                minHMm?: number;
                                /** @description The least width, in millimetres. */
                                minWMm?: number;
                            };
                            /** @description Whether, and how far, a customer may rotate the layer. */
                            rotate: {
                                /** @description A hint shown to the customer under the control. */
                                description?: string;
                                /** @description Whether a customer may change it. */
                                editable: boolean;
                                /** @description What a customer reads the control as. */
                                label?: string;
                                /** @description The most rotation, in degrees. */
                                max?: number;
                                /** @description The least rotation, in degrees. */
                                min?: number;
                                /** @description The angle rotation snaps to, in degrees, e.g. 15. */
                                snapDeg?: number;
                            };
                            /** @description Whether, and how far, a customer may scale the layer. */
                            scale: {
                                /** @description A hint shown to the customer under the control. */
                                description?: string;
                                /** @description Whether a customer may change it. */
                                editable: boolean;
                                /** @description What a customer reads the control as. */
                                label?: string;
                                /** @description The most scale; 1 is as authored. */
                                max?: number;
                                /** @description The least scale; 1 is as authored. */
                                min?: number;
                                /** @description The step between the scales a customer may choose. */
                                step?: number;
                            };
                            /** @description Whether, and within what, a customer may move the layer. */
                            translate: {
                                /** @description Where a customer's move must keep the layer: inside the safe area (the default), the print box, or anywhere. */
                                bounds?: string;
                                /** @description A hint shown to the customer under the control. */
                                description?: string;
                                /** @description Whether a customer may change it. */
                                editable: boolean;
                                /** @description What a customer reads the control as. */
                                label?: string;
                                /** @description What a move snaps to: centre, thirds, safeEdges, layers. */
                                snapTo?: string[];
                            };
                            /** @description The layer's rotation, scale and flip. */
                            value: {
                                /** @description Whether the layer is mirrored left to right, about its centre and before its rotation. */
                                flipX?: boolean;
                                /** @description Whether the layer is mirrored top to bottom, about its centre and before its rotation. */
                                flipY?: boolean;
                                /** @description Rotation about the layer's anchor, in degrees, clockwise. */
                                rotationDeg: number;
                                /** @description Scale of the layer; 1 is as authored. */
                                scale: number;
                            };
                        };
                        type: string;
                        /**
                         * @description true lays spot varnish exactly where the layer is, on a machine that varnishes; it still prints in colour.
                         * @enum {boolean}
                         */
                        varnish?: true;
                        /** @description The layer's width as a fraction of the reference's width. Positive; uncapped, so above 1 hangs over the edge and is clipped. */
                        wFrac: number;
                    };
                    /** @description How many shape layers a customer may add, 1 to 20. */
                    max: number;
                };
                /** @description Whether, and how, a customer may add text layers. */
                text?: {
                    /** @description The preset every added text layer starts as: a text layer without id, name, z, anchorTo, locked or print. What it offers is what a customer may change on the layers they add. */
                    layer: {
                        /** @description The point of the reference the layer is placed against, and the layer's own matching point: top-left puts the layer's top-left corner on the reference's. */
                        anchor: string;
                        /** @description How it mixes with the layers under it, per ink. Absent is normal. */
                        blend?: string;
                        /** @description The layer's height as a fraction of the reference's height. Positive; uncapped, so above 1 hangs over the edge and is clipped. */
                        hFrac: number;
                        /** @description A backdrop painted behind this layer's content at exactly its box: a colour, or a filled shape. Text and image layers only. */
                        mat?: {
                            /** @description The backdrop's colour. */
                            color: {
                                /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                cmyk: [
                                    number,
                                    number,
                                    number,
                                    number
                                ];
                            } | {
                                /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                                spot: {
                                    /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                    fallback: {
                                        /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                        cmyk: [
                                            number,
                                            number,
                                            number,
                                            number
                                        ];
                                    };
                                    /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                    name: string;
                                    /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                    preview?: {
                                        /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                        rgb: [
                                            number,
                                            number,
                                            number
                                        ];
                                    };
                                };
                            } | {
                                /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                ink: string;
                            } | {
                                /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                                entry: string;
                                /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                                palette: string;
                            };
                            /**
                             * @description color is a plain backdrop; shape fills a silhouette.
                             * @enum {string}
                             */
                            kind: "color";
                        } | {
                            /** @description The silhouette's colour. */
                            fill: {
                                /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                cmyk: [
                                    number,
                                    number,
                                    number,
                                    number
                                ];
                            } | {
                                /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                                spot: {
                                    /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                    fallback: {
                                        /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                        cmyk: [
                                            number,
                                            number,
                                            number,
                                            number
                                        ];
                                    };
                                    /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                    name: string;
                                    /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                    preview?: {
                                        /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                        rgb: [
                                            number,
                                            number,
                                            number
                                        ];
                                    };
                                };
                            } | {
                                /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                ink: string;
                            } | {
                                /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                                entry: string;
                                /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                                palette: string;
                            };
                            /**
                             * @description color is a plain backdrop; shape fills a silhouette.
                             * @enum {string}
                             */
                            kind: "shape";
                            /** @description The backdrop's silhouette, at the layer's box. */
                            shape: {
                                /** @description SVG path data in fractions of its box, (0,0) its top-left and (1,1) its bottom-right: `M 0 0 L 1 0 L 1 1 L 0 1 Z` is the whole box. No arcs. */
                                dFrac: string;
                                /**
                                 * @description Inline path geometry.
                                 * @enum {string}
                                 */
                                type: "path";
                            } | {
                                /** @description The shape's id, `shp_…`, as list_shapes returns it. */
                                shapeId: string;
                                /**
                                 * @description One of the tenant's shapes, by id.
                                 * @enum {string}
                                 */
                                type: "shape";
                            };
                        };
                        /** @description How far the layer sits from its anchor, as fractions of the reference, always toward the reference's centre: { x: 0.05, y: 0.05 } nudges it 5 % in from any corner. Ignored on a centred axis. */
                        offsetFrac: {
                            /** @description Across, as a fraction of the reference's width: 0.05 is 5 %. Toward the centre; negative pushes outward. Uncapped. */
                            x: number;
                            /** @description Down or up, as a fraction of the reference's height: 0.05 is 5 %. Toward the centre; negative pushes outward. Uncapped. */
                            y: number;
                        };
                        /** @description The layer's opacity, which a customer may be offered. Absent is full and not offered. */
                        opacity?: {
                            /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                            constraints?: {
                                /** @description The most opacity a customer may choose, 0.01 to 1. */
                                max?: number;
                                /** @description The least opacity a customer may choose, 0.01 to 1. */
                                min?: number;
                                /** @description The step between choosable opacities, e.g. 0.05. */
                                step?: number;
                            };
                            /** @description A hint shown to the customer under the attribute's field. */
                            description?: string;
                            /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                            editable: boolean;
                            /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                            fieldKey?: string;
                            /** @description What a customer reads the attribute as, when editable. */
                            label?: string;
                            /** @description How opaque the whole layer is: 1 is full, 0.01 the least. */
                            value: number;
                        };
                        props: {
                            /** @description Horizontal alignment in the text box. */
                            align: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most characters a customer may type. */
                                    maxLength?: number;
                                    /** @description The most lines a customer's text may take. */
                                    maxLines?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description Whether a customer must change the template's default (a placeholder name or photo) before a design is accepted. Only on an offered text's content, image's picture, or shape's outline or fill. */
                                    requireChange?: boolean;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: string;
                            };
                            /** @description The text. */
                            content: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most characters a customer may type. */
                                    maxLength?: number;
                                    /** @description The most lines a customer's text may take. */
                                    maxLines?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description Whether a customer must change the template's default (a placeholder name or photo) before a design is accepted. Only on an offered text's content, image's picture, or shape's outline or fill. */
                                    requireChange?: boolean;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: string;
                            };
                            /** @description The colour of the text, or a gradient across it. */
                            fill: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /**
                                     * @description true lets a customer choose any colour, beside or instead of a palette.
                                     * @enum {boolean}
                                     */
                                    anyColor: true;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                                    palette: string;
                                } | {
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                                    palette?: string;
                                } | {
                                    /**
                                     * @description true lets a customer choose any colour, beside or instead of a palette.
                                     * @enum {boolean}
                                     */
                                    anyColor: true;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: {
                                    /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                    cmyk: [
                                        number,
                                        number,
                                        number,
                                        number
                                    ];
                                } | {
                                    /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                                    spot: {
                                        /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                        fallback: {
                                            /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                            cmyk: [
                                                number,
                                                number,
                                                number,
                                                number
                                            ];
                                        };
                                        /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                        name: string;
                                        /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                        preview?: {
                                            /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                            rgb: [
                                                number,
                                                number,
                                                number
                                            ];
                                        };
                                    };
                                } | {
                                    /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                    ink: string;
                                } | {
                                    /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                                    entry: string;
                                    /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                                    palette: string;
                                } | {
                                    /** @description linear crosses a shape's box or text's letters at an angle; radial from the centre to the farthest corner. */
                                    gradient: {
                                        /** @description The direction the colours run, in degrees clockwise from straight up: 90 runs left to right, 180 top to bottom. It spans a shape's box or a text's letters. */
                                        angleDeg: number;
                                        /** @enum {string} */
                                        kind: "linear";
                                        /** @description The gradient's colours, 2 to 8, in order of position. Blended in CMYK, as the print blends them. */
                                        stops: {
                                            /** @description Where the colour sits along the gradient: 0 is its start, 1 its end. Stops are in order; two at one position make a hard edge. */
                                            at: number;
                                            /** @description The colour at this stop: a CMYK colour, one of your inks, or a palette entry. A spot ink cannot be one: a gradient blends process colours. */
                                            color: {
                                                /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                                cmyk: [
                                                    number,
                                                    number,
                                                    number,
                                                    number
                                                ];
                                            } | {
                                                /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                                                spot: {
                                                    /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                                    fallback: {
                                                        /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                                        cmyk: [
                                                            number,
                                                            number,
                                                            number,
                                                            number
                                                        ];
                                                    };
                                                    /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                                    name: string;
                                                    /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                                    preview?: {
                                                        /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                                        rgb: [
                                                            number,
                                                            number,
                                                            number
                                                        ];
                                                    };
                                                };
                                            } | {
                                                /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                                ink: string;
                                            } | {
                                                /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                                                entry: string;
                                                /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                                                palette: string;
                                            };
                                        }[];
                                    } | {
                                        /** @enum {string} */
                                        kind: "radial";
                                        /** @description The gradient's colours, 2 to 8, in order of position. Blended in CMYK, as the print blends them. */
                                        stops: {
                                            /** @description Where the colour sits along the gradient: 0 is its start, 1 its end. Stops are in order; two at one position make a hard edge. */
                                            at: number;
                                            /** @description The colour at this stop: a CMYK colour, one of your inks, or a palette entry. A spot ink cannot be one: a gradient blends process colours. */
                                            color: {
                                                /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                                cmyk: [
                                                    number,
                                                    number,
                                                    number,
                                                    number
                                                ];
                                            } | {
                                                /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                                                spot: {
                                                    /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                                    fallback: {
                                                        /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                                        cmyk: [
                                                            number,
                                                            number,
                                                            number,
                                                            number
                                                        ];
                                                    };
                                                    /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                                    name: string;
                                                    /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                                    preview?: {
                                                        /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                                        rgb: [
                                                            number,
                                                            number,
                                                            number
                                                        ];
                                                    };
                                                };
                                            } | {
                                                /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                                ink: string;
                                            } | {
                                                /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                                                entry: string;
                                                /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                                                palette: string;
                                            };
                                        }[];
                                    };
                                };
                            };
                            /** @description The font family, one of those the tenant offers. */
                            fontFamily: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most characters a customer may type. */
                                    maxLength?: number;
                                    /** @description The most lines a customer's text may take. */
                                    maxLines?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description Whether a customer must change the template's default (a placeholder name or photo) before a design is accepted. Only on an offered text's content, image's picture, or shape's outline or fill. */
                                    requireChange?: boolean;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: string;
                            };
                            /** @description The font size as a fraction of the plate's HEIGHT, as is its offered range: 0.05 is 5 % of the height. Positive. */
                            fontSizeFrac: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most value a customer may choose. */
                                    max?: number;
                                    /** @description The least value a customer may choose. */
                                    min?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The step between the values a customer may choose. */
                                    step?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: number;
                            };
                            /** @description Upright (normal) or italic; absent is normal. An italic text draws its font's italic faces, or its upright ones when the font has none. Set by the author: a customer is not offered it. */
                            fontStyle?: {
                                /**
                                 * @description Always false: the author sets it, a customer may not.
                                 * @enum {boolean}
                                 */
                                editable: false;
                                /** @description The attribute's value, as the template stores it. */
                                value: string;
                            };
                            /** @description The font weight, 1 to 1000; 400 is regular, 700 bold. */
                            fontWeight?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most value a customer may choose. */
                                    max?: number;
                                    /** @description The least value a customer may choose. */
                                    min?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The step between the values a customer may choose. */
                                    step?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: number;
                            };
                            /** @description The space added after each letter, as a fraction of the drawn text size (0.1 is a tenth of it), -0.1 to 1; absent or 0 is the font's own spacing. */
                            letterSpacingEm?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most value a customer may choose. */
                                    max?: number;
                                    /** @description The least value a customer may choose. */
                                    min?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The step between the values a customer may choose. */
                                    step?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: number;
                            };
                            /** @description The line spacing as a multiple of the font's own, 0.5 to 3; absent or 1 is the font's own. */
                            lineHeight?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most value a customer may choose. */
                                    max?: number;
                                    /** @description The least value a customer may choose. */
                                    min?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The step between the values a customer may choose. */
                                    step?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: number;
                            };
                            /** @description The colour of the line drawn around every letter, outside its fill; absent is black. */
                            outlineColor?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /**
                                     * @description true lets a customer choose any colour, beside or instead of a palette.
                                     * @enum {boolean}
                                     */
                                    anyColor: true;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                                    palette: string;
                                } | {
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                                    palette?: string;
                                } | {
                                    /**
                                     * @description true lets a customer choose any colour, beside or instead of a palette.
                                     * @enum {boolean}
                                     */
                                    anyColor: true;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: {
                                    /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                    cmyk: [
                                        number,
                                        number,
                                        number,
                                        number
                                    ];
                                } | {
                                    /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                                    spot: {
                                        /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                        fallback: {
                                            /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                            cmyk: [
                                                number,
                                                number,
                                                number,
                                                number
                                            ];
                                        };
                                        /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                        name: string;
                                        /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                        preview?: {
                                            /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                            rgb: [
                                                number,
                                                number,
                                                number
                                            ];
                                        };
                                    };
                                } | {
                                    /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                    ink: string;
                                } | {
                                    /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                                    entry: string;
                                    /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                                    palette: string;
                                };
                            };
                            /** @description The outline's width as a fraction of the drawn text size (0.05 is a twentieth of it), 0 to 0.25; absent or 0 draws no outline. */
                            outlineWidthEm?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most value a customer may choose. */
                                    max?: number;
                                    /** @description The least value a customer may choose. */
                                    min?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The step between the values a customer may choose. */
                                    step?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: number;
                            };
                            /** @description How soft the shadow is: its blur radius as a fraction of the drawn text size, 0 (sharp) to 1. A shadow with no offset and no blur draws nothing. */
                            shadowBlurEm?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most value a customer may choose. */
                                    max?: number;
                                    /** @description The least value a customer may choose. */
                                    min?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The step between the values a customer may choose. */
                                    step?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: number;
                            };
                            /** @description The colour of the shadow drawn under the text; absent is black. */
                            shadowColor?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /**
                                     * @description true lets a customer choose any colour, beside or instead of a palette.
                                     * @enum {boolean}
                                     */
                                    anyColor: true;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                                    palette: string;
                                } | {
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                                    palette?: string;
                                } | {
                                    /**
                                     * @description true lets a customer choose any colour, beside or instead of a palette.
                                     * @enum {boolean}
                                     */
                                    anyColor: true;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: {
                                    /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                    cmyk: [
                                        number,
                                        number,
                                        number,
                                        number
                                    ];
                                } | {
                                    /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                                    spot: {
                                        /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                        fallback: {
                                            /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                            cmyk: [
                                                number,
                                                number,
                                                number,
                                                number
                                            ];
                                        };
                                        /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                        name: string;
                                        /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                        preview?: {
                                            /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                            rgb: [
                                                number,
                                                number,
                                                number
                                            ];
                                        };
                                    };
                                } | {
                                    /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                    ink: string;
                                } | {
                                    /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                                    entry: string;
                                    /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                                    palette: string;
                                };
                            };
                            /** @description How far right the shadow falls, as a fraction of the drawn text size, -1 to 1; negative is left. */
                            shadowOffsetXEm?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most value a customer may choose. */
                                    max?: number;
                                    /** @description The least value a customer may choose. */
                                    min?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The step between the values a customer may choose. */
                                    step?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: number;
                            };
                            /** @description How far down the shadow falls, as a fraction of the drawn text size, -1 to 1; negative is up. */
                            shadowOffsetYEm?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most value a customer may choose. */
                                    max?: number;
                                    /** @description The least value a customer may choose. */
                                    min?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The step between the values a customer may choose. */
                                    step?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: number;
                            };
                            /** @description How the letters are cased when drawn: asTyped, upper, lower or title (each word's first letter a capital). The text itself is kept as typed. Absent is asTyped. */
                            textCase?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most characters a customer may type. */
                                    maxLength?: number;
                                    /** @description The most lines a customer's text may take. */
                                    maxLines?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description Whether a customer must change the template's default (a placeholder name or photo) before a design is accepted. Only on an offered text's content, image's picture, or shape's outline or fill. */
                                    requireChange?: boolean;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: string;
                            };
                            /** @description Vertical alignment in the text box; absent is middle. */
                            valign?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most characters a customer may type. */
                                    maxLength?: number;
                                    /** @description The most lines a customer's text may take. */
                                    maxLines?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description Whether a customer must change the template's default (a placeholder name or photo) before a design is accepted. Only on an offered text's content, image's picture, or shape's outline or fill. */
                                    requireChange?: boolean;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: string;
                            };
                        };
                        /** @description What the text layer does when its text does not fit its box. Every size here is a fraction of the plate. */
                        textBox: {
                            /**
                             * @description true breaks a word wider than the box across lines rather than refusing it.
                             * @enum {boolean}
                             */
                            breakWords?: true;
                            /**
                             * @description adapt keeps the font size and grows the box, then shrinks the text, as far as the limits below allow.
                             * @enum {string}
                             */
                            mode: "adapt";
                            /** @description Which way the box grows first. Absent is widerFirst. */
                            order?: string;
                            /** @description The smallest font size the text may shrink to, as a fraction of the plate's height. Absent, it does not shrink. */
                            shrinkTo?: number;
                            /** @description How tall the box may grow, as a fraction of the plate's height, at most 1. Absent, it does not grow taller. */
                            tallerTo?: number;
                            /** @description What happens to text that still does not fit: clamp cuts it at the box, reject refuses the text. */
                            then: string;
                            /** @description How wide the box may grow, as a fraction of the plate's width, at most 1. Absent, it does not widen. */
                            widenTo?: number;
                        } | {
                            /**
                             * @description true breaks a word wider than the box across lines rather than refusing it.
                             * @enum {boolean}
                             */
                            breakWords?: true;
                            /** @description The largest font size, as a fraction of the plate's height; null is no limit, as large as one line of the box. */
                            max: number | null;
                            /** @description The smallest font size, as a fraction of the plate's height. */
                            min: number;
                            /**
                             * @description fill sizes the text to fill the box, between min and max.
                             * @enum {string}
                             */
                            mode: "fill";
                            /** @description What happens to text that still does not fit: clamp cuts it at the box, reject refuses the text. */
                            then: string;
                        };
                        /** @description A curve the text runs along, as one line: absent is straight lines. The text box still fits it along the curve's length: it shrinks, then is cut or refused, never widening or growing taller. */
                        textPath?: {
                            /** @description Where the text's run is centred, in degrees clockwise from 12 o'clock: 0 is the top, 90 the right, 180 the bottom. */
                            centerDeg: number;
                            /** @description Which side of the curve the letters stand on: outside reads clockwise round it (the top of a badge); inside hangs inside it and runs the other way, so text at the bottom reads left to right. */
                            side: string;
                            /** @description How much of the oval the arc covers, in degrees, above 0 and at most 360: 360 is a whole circle. */
                            sweepDeg: number;
                            /**
                             * @description Along the oval inside the layer's box, a circle when the box is square: the box is the radius.
                             * @enum {string}
                             */
                            type: "arc";
                        } | {
                            /** @description Where the text's run is centred, in degrees clockwise from 12 o'clock: 0 is the top, 90 the right, 180 the bottom. */
                            centerDeg: number;
                            shape: {
                                /** @description SVG path data in fractions of its box, (0,0) its top-left and (1,1) its bottom-right: `M 0 0 L 1 0 L 1 1 L 0 1 Z` is the whole box. No arcs. */
                                dFrac: string;
                                /**
                                 * @description Inline path geometry.
                                 * @enum {string}
                                 */
                                type: "path";
                            } | {
                                /** @description The shape's id, `shp_…`, as list_shapes returns it. */
                                shapeId: string;
                                /**
                                 * @description One of the tenant's shapes, by id.
                                 * @enum {string}
                                 */
                                type: "shape";
                            };
                            /** @description Which side of the curve the letters stand on: outside reads clockwise round it (the top of a badge); inside hangs inside it and runs the other way, so text at the bottom reads left to right. */
                            side: string;
                            /**
                             * @description Once round a shape's outline, stretched to the layer's box: a closed outline's run is centred where a ray from the box's centre at centerDeg crosses it; an open one runs from its first point.
                             * @enum {string}
                             */
                            type: "outline";
                        };
                        /** @description The layer's rotation, scale and flip, and which of them, and its position, a customer may change. */
                        transform: {
                            /** @description Whether a customer may flip the layer. */
                            flip?: {
                                /** @description A hint shown to the customer under the control. */
                                description?: string;
                                /** @description Whether a customer may change it. */
                                editable: boolean;
                                /** @description What a customer reads the control as. */
                                label?: string;
                            };
                            /** @description Whether, and within what, a customer may resize the layer. */
                            resize?: {
                                /** @description A hint shown to the customer under the control. */
                                description?: string;
                                /** @description Whether a customer may change it. */
                                editable?: boolean;
                                /** @description What a customer reads the control as. */
                                label?: string;
                                /** @description The most height, in millimetres. */
                                maxHMm?: number;
                                /** @description The most width, in millimetres. */
                                maxWMm?: number;
                                /** @description The least height, in millimetres. */
                                minHMm?: number;
                                /** @description The least width, in millimetres. */
                                minWMm?: number;
                            };
                            /** @description Whether, and how far, a customer may rotate the layer. */
                            rotate: {
                                /** @description A hint shown to the customer under the control. */
                                description?: string;
                                /** @description Whether a customer may change it. */
                                editable: boolean;
                                /** @description What a customer reads the control as. */
                                label?: string;
                                /** @description The most rotation, in degrees. */
                                max?: number;
                                /** @description The least rotation, in degrees. */
                                min?: number;
                                /** @description The angle rotation snaps to, in degrees, e.g. 15. */
                                snapDeg?: number;
                            };
                            /** @description Whether, and how far, a customer may scale the layer. */
                            scale: {
                                /** @description A hint shown to the customer under the control. */
                                description?: string;
                                /** @description Whether a customer may change it. */
                                editable: boolean;
                                /** @description What a customer reads the control as. */
                                label?: string;
                                /** @description The most scale; 1 is as authored. */
                                max?: number;
                                /** @description The least scale; 1 is as authored. */
                                min?: number;
                                /** @description The step between the scales a customer may choose. */
                                step?: number;
                            };
                            /** @description Whether, and within what, a customer may move the layer. */
                            translate: {
                                /** @description Where a customer's move must keep the layer: inside the safe area (the default), the print box, or anywhere. */
                                bounds?: string;
                                /** @description A hint shown to the customer under the control. */
                                description?: string;
                                /** @description Whether a customer may change it. */
                                editable: boolean;
                                /** @description What a customer reads the control as. */
                                label?: string;
                                /** @description What a move snaps to: centre, thirds, safeEdges, layers. */
                                snapTo?: string[];
                            };
                            /** @description The layer's rotation, scale and flip. */
                            value: {
                                /** @description Whether the layer is mirrored left to right, about its centre and before its rotation. */
                                flipX?: boolean;
                                /** @description Whether the layer is mirrored top to bottom, about its centre and before its rotation. */
                                flipY?: boolean;
                                /** @description Rotation about the layer's anchor, in degrees, clockwise. */
                                rotationDeg: number;
                                /** @description Scale of the layer; 1 is as authored. */
                                scale: number;
                            };
                        };
                        type: string;
                        /**
                         * @description true lays spot varnish exactly where the layer is, on a machine that varnishes; it still prints in colour.
                         * @enum {boolean}
                         */
                        varnish?: true;
                        /** @description The layer's width as a fraction of the reference's width. Positive; uncapped, so above 1 hangs over the edge and is clipped. */
                        wFrac: number;
                    };
                    /** @description How many text layers a customer may add, 1 to 20. */
                    max: number;
                };
            };
            /** @description The resolution the artwork is drawn at, in dots per inch; 300 is usual for print. */
            dpi: number;
            /** @description true: the customer's canvas keeps the ratio at every print size, and the print is cropped or banded by fit. Absent is false. */
            drawAtTemplateRatio?: boolean;
            /** @description The family of `fonts` a character a text's own family lacks is drawn in, at the text's weight and style: the tenant's default font family when the version was published. */
            fallbackFamily?: string;
            /** @description How the artwork sits in a print box of another shape: contain, cover or fill. */
            fit: string;
            fonts?: {
                [key: string]: {
                    hash: string;
                    style?: string;
                    weight: number;
                }[];
            };
            form?: {
                layout?: string;
            };
            groups?: {
                id: string;
                label: string;
                layerIds: string[];
                order: number;
            }[];
            id: string;
            layers: ({
                /** @description The point of the reference the layer is placed against, and the layer's own matching point: top-left puts the layer's top-left corner on the reference's. */
                anchor: string;
                /** @description Another layer's id, to place and size this one against that layer's box instead of the plate. A missing layer falls back to the plate. */
                anchorTo?: string;
                /** @description How it mixes with the layers under it, per ink. Absent is normal. */
                blend?: string;
                /** @description The layer's height as a fraction of the reference's height. Positive; uncapped, so above 1 hangs over the edge and is clipped. */
                hFrac: number;
                /** @description The layer's id: what anchorTo, groups and a customer's values name it by. Never changes. */
                id: string;
                /**
                 * @description true locks the layer on the author's canvas: clicks pass through and it cannot be deleted. Absent is unlocked.
                 * @enum {boolean}
                 */
                locked?: true;
                /** @description A backdrop painted behind this layer's content at exactly its box: a colour, or a filled shape. Text and image layers only. */
                mat?: {
                    /** @description The backdrop's colour. */
                    color: {
                        /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                        cmyk: [
                            number,
                            number,
                            number,
                            number
                        ];
                    } | {
                        /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                        spot: {
                            /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                            fallback: {
                                /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                cmyk: [
                                    number,
                                    number,
                                    number,
                                    number
                                ];
                            };
                            /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                            name: string;
                            /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                            preview?: {
                                /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                rgb: [
                                    number,
                                    number,
                                    number
                                ];
                            };
                        };
                    } | {
                        /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                        ink: string;
                    } | {
                        /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                        entry: string;
                        /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                        palette: string;
                    };
                    /**
                     * @description color is a plain backdrop; shape fills a silhouette.
                     * @enum {string}
                     */
                    kind: "color";
                } | {
                    /** @description The silhouette's colour. */
                    fill: {
                        /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                        cmyk: [
                            number,
                            number,
                            number,
                            number
                        ];
                    } | {
                        /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                        spot: {
                            /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                            fallback: {
                                /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                cmyk: [
                                    number,
                                    number,
                                    number,
                                    number
                                ];
                            };
                            /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                            name: string;
                            /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                            preview?: {
                                /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                rgb: [
                                    number,
                                    number,
                                    number
                                ];
                            };
                        };
                    } | {
                        /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                        ink: string;
                    } | {
                        /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                        entry: string;
                        /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                        palette: string;
                    };
                    /**
                     * @description color is a plain backdrop; shape fills a silhouette.
                     * @enum {string}
                     */
                    kind: "shape";
                    /** @description The backdrop's silhouette, at the layer's box. */
                    shape: {
                        /** @description SVG path data in fractions of its box, (0,0) its top-left and (1,1) its bottom-right: `M 0 0 L 1 0 L 1 1 L 0 1 Z` is the whole box. No arcs. */
                        dFrac: string;
                        /**
                         * @description Inline path geometry.
                         * @enum {string}
                         */
                        type: "path";
                    } | {
                        /** @description The shape's id, `shp_…`, as list_shapes returns it. */
                        shapeId: string;
                        /**
                         * @description One of the tenant's shapes, by id.
                         * @enum {string}
                         */
                        type: "shape";
                    };
                };
                /** @description What the author reads the layer as. Not unique; absent, the layer reads as its id. */
                name?: string;
                /** @description How far the layer sits from its anchor, as fractions of the reference, always toward the reference's centre: { x: 0.05, y: 0.05 } nudges it 5 % in from any corner. Ignored on a centred axis. */
                offsetFrac: {
                    /** @description Across, as a fraction of the reference's width: 0.05 is 5 %. Toward the centre; negative pushes outward. Uncapped. */
                    x: number;
                    /** @description Down or up, as a fraction of the reference's height: 0.05 is 5 %. Toward the centre; negative pushes outward. Uncapped. */
                    y: number;
                };
                /** @description The layer's opacity, which a customer may be offered. Absent is full and not offered. */
                opacity?: {
                    /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                    constraints?: {
                        /** @description The most opacity a customer may choose, 0.01 to 1. */
                        max?: number;
                        /** @description The least opacity a customer may choose, 0.01 to 1. */
                        min?: number;
                        /** @description The step between choosable opacities, e.g. 0.05. */
                        step?: number;
                    };
                    /** @description A hint shown to the customer under the attribute's field. */
                    description?: string;
                    /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                    editable: boolean;
                    /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                    fieldKey?: string;
                    /** @description What a customer reads the attribute as, when editable. */
                    label?: string;
                    /** @description How opaque the whole layer is: 1 is full, 0.01 the least. */
                    value: number;
                };
                /**
                 * @description false makes it a guide layer: laid out and drawn on the author's canvas, never printed or shown to a customer. Absent prints.
                 * @enum {boolean}
                 */
                print?: false;
                props: {
                    /** @description Horizontal alignment in the text box. */
                    align: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most characters a customer may type. */
                            maxLength?: number;
                            /** @description The most lines a customer's text may take. */
                            maxLines?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description Whether a customer must change the template's default (a placeholder name or photo) before a design is accepted. Only on an offered text's content, image's picture, or shape's outline or fill. */
                            requireChange?: boolean;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: string;
                    };
                    /** @description The text. */
                    content: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most characters a customer may type. */
                            maxLength?: number;
                            /** @description The most lines a customer's text may take. */
                            maxLines?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description Whether a customer must change the template's default (a placeholder name or photo) before a design is accepted. Only on an offered text's content, image's picture, or shape's outline or fill. */
                            requireChange?: boolean;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: string;
                    };
                    /** @description The colour of the text, or a gradient across it. */
                    fill: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /**
                             * @description true lets a customer choose any colour, beside or instead of a palette.
                             * @enum {boolean}
                             */
                            anyColor: true;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                            palette: string;
                        } | {
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                            palette?: string;
                        } | {
                            /**
                             * @description true lets a customer choose any colour, beside or instead of a palette.
                             * @enum {boolean}
                             */
                            anyColor: true;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: {
                            /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                            cmyk: [
                                number,
                                number,
                                number,
                                number
                            ];
                        } | {
                            /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                            spot: {
                                /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                fallback: {
                                    /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                    cmyk: [
                                        number,
                                        number,
                                        number,
                                        number
                                    ];
                                };
                                /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                name: string;
                                /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                preview?: {
                                    /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                    rgb: [
                                        number,
                                        number,
                                        number
                                    ];
                                };
                            };
                        } | {
                            /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                            ink: string;
                        } | {
                            /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                            entry: string;
                            /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                            palette: string;
                        } | {
                            /** @description linear crosses a shape's box or text's letters at an angle; radial from the centre to the farthest corner. */
                            gradient: {
                                /** @description The direction the colours run, in degrees clockwise from straight up: 90 runs left to right, 180 top to bottom. It spans a shape's box or a text's letters. */
                                angleDeg: number;
                                /** @enum {string} */
                                kind: "linear";
                                /** @description The gradient's colours, 2 to 8, in order of position. Blended in CMYK, as the print blends them. */
                                stops: {
                                    /** @description Where the colour sits along the gradient: 0 is its start, 1 its end. Stops are in order; two at one position make a hard edge. */
                                    at: number;
                                    /** @description The colour at this stop: a CMYK colour, one of your inks, or a palette entry. A spot ink cannot be one: a gradient blends process colours. */
                                    color: {
                                        /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                        cmyk: [
                                            number,
                                            number,
                                            number,
                                            number
                                        ];
                                    } | {
                                        /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                                        spot: {
                                            /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                            fallback: {
                                                /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                                cmyk: [
                                                    number,
                                                    number,
                                                    number,
                                                    number
                                                ];
                                            };
                                            /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                            name: string;
                                            /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                            preview?: {
                                                /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                                rgb: [
                                                    number,
                                                    number,
                                                    number
                                                ];
                                            };
                                        };
                                    } | {
                                        /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                        ink: string;
                                    } | {
                                        /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                                        entry: string;
                                        /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                                        palette: string;
                                    };
                                }[];
                            } | {
                                /** @enum {string} */
                                kind: "radial";
                                /** @description The gradient's colours, 2 to 8, in order of position. Blended in CMYK, as the print blends them. */
                                stops: {
                                    /** @description Where the colour sits along the gradient: 0 is its start, 1 its end. Stops are in order; two at one position make a hard edge. */
                                    at: number;
                                    /** @description The colour at this stop: a CMYK colour, one of your inks, or a palette entry. A spot ink cannot be one: a gradient blends process colours. */
                                    color: {
                                        /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                        cmyk: [
                                            number,
                                            number,
                                            number,
                                            number
                                        ];
                                    } | {
                                        /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                                        spot: {
                                            /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                            fallback: {
                                                /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                                cmyk: [
                                                    number,
                                                    number,
                                                    number,
                                                    number
                                                ];
                                            };
                                            /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                            name: string;
                                            /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                            preview?: {
                                                /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                                rgb: [
                                                    number,
                                                    number,
                                                    number
                                                ];
                                            };
                                        };
                                    } | {
                                        /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                        ink: string;
                                    } | {
                                        /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                                        entry: string;
                                        /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                                        palette: string;
                                    };
                                }[];
                            };
                        };
                    };
                    /** @description The font family, one of those the tenant offers. */
                    fontFamily: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most characters a customer may type. */
                            maxLength?: number;
                            /** @description The most lines a customer's text may take. */
                            maxLines?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description Whether a customer must change the template's default (a placeholder name or photo) before a design is accepted. Only on an offered text's content, image's picture, or shape's outline or fill. */
                            requireChange?: boolean;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: string;
                    };
                    /** @description The font size as a fraction of the plate's HEIGHT, as is its offered range: 0.05 is 5 % of the height. Positive. */
                    fontSizeFrac: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most value a customer may choose. */
                            max?: number;
                            /** @description The least value a customer may choose. */
                            min?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The step between the values a customer may choose. */
                            step?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: number;
                    };
                    /** @description Upright (normal) or italic; absent is normal. An italic text draws its font's italic faces, or its upright ones when the font has none. Set by the author: a customer is not offered it. */
                    fontStyle?: {
                        /**
                         * @description Always false: the author sets it, a customer may not.
                         * @enum {boolean}
                         */
                        editable: false;
                        /** @description The attribute's value, as the template stores it. */
                        value: string;
                    };
                    /** @description The font weight, 1 to 1000; 400 is regular, 700 bold. */
                    fontWeight?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most value a customer may choose. */
                            max?: number;
                            /** @description The least value a customer may choose. */
                            min?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The step between the values a customer may choose. */
                            step?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: number;
                    };
                    /** @description The space added after each letter, as a fraction of the drawn text size (0.1 is a tenth of it), -0.1 to 1; absent or 0 is the font's own spacing. */
                    letterSpacingEm?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most value a customer may choose. */
                            max?: number;
                            /** @description The least value a customer may choose. */
                            min?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The step between the values a customer may choose. */
                            step?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: number;
                    };
                    /** @description The line spacing as a multiple of the font's own, 0.5 to 3; absent or 1 is the font's own. */
                    lineHeight?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most value a customer may choose. */
                            max?: number;
                            /** @description The least value a customer may choose. */
                            min?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The step between the values a customer may choose. */
                            step?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: number;
                    };
                    /** @description The colour of the line drawn around every letter, outside its fill; absent is black. */
                    outlineColor?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /**
                             * @description true lets a customer choose any colour, beside or instead of a palette.
                             * @enum {boolean}
                             */
                            anyColor: true;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                            palette: string;
                        } | {
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                            palette?: string;
                        } | {
                            /**
                             * @description true lets a customer choose any colour, beside or instead of a palette.
                             * @enum {boolean}
                             */
                            anyColor: true;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: {
                            /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                            cmyk: [
                                number,
                                number,
                                number,
                                number
                            ];
                        } | {
                            /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                            spot: {
                                /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                fallback: {
                                    /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                    cmyk: [
                                        number,
                                        number,
                                        number,
                                        number
                                    ];
                                };
                                /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                name: string;
                                /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                preview?: {
                                    /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                    rgb: [
                                        number,
                                        number,
                                        number
                                    ];
                                };
                            };
                        } | {
                            /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                            ink: string;
                        } | {
                            /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                            entry: string;
                            /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                            palette: string;
                        };
                    };
                    /** @description The outline's width as a fraction of the drawn text size (0.05 is a twentieth of it), 0 to 0.25; absent or 0 draws no outline. */
                    outlineWidthEm?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most value a customer may choose. */
                            max?: number;
                            /** @description The least value a customer may choose. */
                            min?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The step between the values a customer may choose. */
                            step?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: number;
                    };
                    /** @description How soft the shadow is: its blur radius as a fraction of the drawn text size, 0 (sharp) to 1. A shadow with no offset and no blur draws nothing. */
                    shadowBlurEm?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most value a customer may choose. */
                            max?: number;
                            /** @description The least value a customer may choose. */
                            min?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The step between the values a customer may choose. */
                            step?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: number;
                    };
                    /** @description The colour of the shadow drawn under the text; absent is black. */
                    shadowColor?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /**
                             * @description true lets a customer choose any colour, beside or instead of a palette.
                             * @enum {boolean}
                             */
                            anyColor: true;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                            palette: string;
                        } | {
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                            palette?: string;
                        } | {
                            /**
                             * @description true lets a customer choose any colour, beside or instead of a palette.
                             * @enum {boolean}
                             */
                            anyColor: true;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: {
                            /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                            cmyk: [
                                number,
                                number,
                                number,
                                number
                            ];
                        } | {
                            /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                            spot: {
                                /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                fallback: {
                                    /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                    cmyk: [
                                        number,
                                        number,
                                        number,
                                        number
                                    ];
                                };
                                /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                name: string;
                                /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                preview?: {
                                    /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                    rgb: [
                                        number,
                                        number,
                                        number
                                    ];
                                };
                            };
                        } | {
                            /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                            ink: string;
                        } | {
                            /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                            entry: string;
                            /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                            palette: string;
                        };
                    };
                    /** @description How far right the shadow falls, as a fraction of the drawn text size, -1 to 1; negative is left. */
                    shadowOffsetXEm?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most value a customer may choose. */
                            max?: number;
                            /** @description The least value a customer may choose. */
                            min?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The step between the values a customer may choose. */
                            step?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: number;
                    };
                    /** @description How far down the shadow falls, as a fraction of the drawn text size, -1 to 1; negative is up. */
                    shadowOffsetYEm?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most value a customer may choose. */
                            max?: number;
                            /** @description The least value a customer may choose. */
                            min?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The step between the values a customer may choose. */
                            step?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: number;
                    };
                    /** @description How the letters are cased when drawn: asTyped, upper, lower or title (each word's first letter a capital). The text itself is kept as typed. Absent is asTyped. */
                    textCase?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most characters a customer may type. */
                            maxLength?: number;
                            /** @description The most lines a customer's text may take. */
                            maxLines?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description Whether a customer must change the template's default (a placeholder name or photo) before a design is accepted. Only on an offered text's content, image's picture, or shape's outline or fill. */
                            requireChange?: boolean;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: string;
                    };
                    /** @description Vertical alignment in the text box; absent is middle. */
                    valign?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most characters a customer may type. */
                            maxLength?: number;
                            /** @description The most lines a customer's text may take. */
                            maxLines?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description Whether a customer must change the template's default (a placeholder name or photo) before a design is accepted. Only on an offered text's content, image's picture, or shape's outline or fill. */
                            requireChange?: boolean;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: string;
                    };
                };
                /** @description What the text layer does when its text does not fit its box. Every size here is a fraction of the plate. */
                textBox: {
                    /**
                     * @description true breaks a word wider than the box across lines rather than refusing it.
                     * @enum {boolean}
                     */
                    breakWords?: true;
                    /**
                     * @description adapt keeps the font size and grows the box, then shrinks the text, as far as the limits below allow.
                     * @enum {string}
                     */
                    mode: "adapt";
                    /** @description Which way the box grows first. Absent is widerFirst. */
                    order?: string;
                    /** @description The smallest font size the text may shrink to, as a fraction of the plate's height. Absent, it does not shrink. */
                    shrinkTo?: number;
                    /** @description How tall the box may grow, as a fraction of the plate's height, at most 1. Absent, it does not grow taller. */
                    tallerTo?: number;
                    /** @description What happens to text that still does not fit: clamp cuts it at the box, reject refuses the text. */
                    then: string;
                    /** @description How wide the box may grow, as a fraction of the plate's width, at most 1. Absent, it does not widen. */
                    widenTo?: number;
                } | {
                    /**
                     * @description true breaks a word wider than the box across lines rather than refusing it.
                     * @enum {boolean}
                     */
                    breakWords?: true;
                    /** @description The largest font size, as a fraction of the plate's height; null is no limit, as large as one line of the box. */
                    max: number | null;
                    /** @description The smallest font size, as a fraction of the plate's height. */
                    min: number;
                    /**
                     * @description fill sizes the text to fill the box, between min and max.
                     * @enum {string}
                     */
                    mode: "fill";
                    /** @description What happens to text that still does not fit: clamp cuts it at the box, reject refuses the text. */
                    then: string;
                };
                /** @description A curve the text runs along, as one line: absent is straight lines. The text box still fits it along the curve's length: it shrinks, then is cut or refused, never widening or growing taller. */
                textPath?: {
                    /** @description Where the text's run is centred, in degrees clockwise from 12 o'clock: 0 is the top, 90 the right, 180 the bottom. */
                    centerDeg: number;
                    /** @description Which side of the curve the letters stand on: outside reads clockwise round it (the top of a badge); inside hangs inside it and runs the other way, so text at the bottom reads left to right. */
                    side: string;
                    /** @description How much of the oval the arc covers, in degrees, above 0 and at most 360: 360 is a whole circle. */
                    sweepDeg: number;
                    /**
                     * @description Along the oval inside the layer's box, a circle when the box is square: the box is the radius.
                     * @enum {string}
                     */
                    type: "arc";
                } | {
                    /** @description Where the text's run is centred, in degrees clockwise from 12 o'clock: 0 is the top, 90 the right, 180 the bottom. */
                    centerDeg: number;
                    shape: {
                        /** @description SVG path data in fractions of its box, (0,0) its top-left and (1,1) its bottom-right: `M 0 0 L 1 0 L 1 1 L 0 1 Z` is the whole box. No arcs. */
                        dFrac: string;
                        /**
                         * @description Inline path geometry.
                         * @enum {string}
                         */
                        type: "path";
                    } | {
                        /** @description The shape's id, `shp_…`, as list_shapes returns it. */
                        shapeId: string;
                        /**
                         * @description One of the tenant's shapes, by id.
                         * @enum {string}
                         */
                        type: "shape";
                    };
                    /** @description Which side of the curve the letters stand on: outside reads clockwise round it (the top of a badge); inside hangs inside it and runs the other way, so text at the bottom reads left to right. */
                    side: string;
                    /**
                     * @description Once round a shape's outline, stretched to the layer's box: a closed outline's run is centred where a ray from the box's centre at centerDeg crosses it; an open one runs from its first point.
                     * @enum {string}
                     */
                    type: "outline";
                };
                /** @description The layer's rotation, scale and flip, and which of them, and its position, a customer may change. */
                transform: {
                    /** @description Whether a customer may flip the layer. */
                    flip?: {
                        /** @description A hint shown to the customer under the control. */
                        description?: string;
                        /** @description Whether a customer may change it. */
                        editable: boolean;
                        /** @description What a customer reads the control as. */
                        label?: string;
                    };
                    /** @description Whether, and within what, a customer may resize the layer. */
                    resize?: {
                        /** @description A hint shown to the customer under the control. */
                        description?: string;
                        /** @description Whether a customer may change it. */
                        editable?: boolean;
                        /** @description What a customer reads the control as. */
                        label?: string;
                        /** @description The most height, in millimetres. */
                        maxHMm?: number;
                        /** @description The most width, in millimetres. */
                        maxWMm?: number;
                        /** @description The least height, in millimetres. */
                        minHMm?: number;
                        /** @description The least width, in millimetres. */
                        minWMm?: number;
                    };
                    /** @description Whether, and how far, a customer may rotate the layer. */
                    rotate: {
                        /** @description A hint shown to the customer under the control. */
                        description?: string;
                        /** @description Whether a customer may change it. */
                        editable: boolean;
                        /** @description What a customer reads the control as. */
                        label?: string;
                        /** @description The most rotation, in degrees. */
                        max?: number;
                        /** @description The least rotation, in degrees. */
                        min?: number;
                        /** @description The angle rotation snaps to, in degrees, e.g. 15. */
                        snapDeg?: number;
                    };
                    /** @description Whether, and how far, a customer may scale the layer. */
                    scale: {
                        /** @description A hint shown to the customer under the control. */
                        description?: string;
                        /** @description Whether a customer may change it. */
                        editable: boolean;
                        /** @description What a customer reads the control as. */
                        label?: string;
                        /** @description The most scale; 1 is as authored. */
                        max?: number;
                        /** @description The least scale; 1 is as authored. */
                        min?: number;
                        /** @description The step between the scales a customer may choose. */
                        step?: number;
                    };
                    /** @description Whether, and within what, a customer may move the layer. */
                    translate: {
                        /** @description Where a customer's move must keep the layer: inside the safe area (the default), the print box, or anywhere. */
                        bounds?: string;
                        /** @description A hint shown to the customer under the control. */
                        description?: string;
                        /** @description Whether a customer may change it. */
                        editable: boolean;
                        /** @description What a customer reads the control as. */
                        label?: string;
                        /** @description What a move snaps to: centre, thirds, safeEdges, layers. */
                        snapTo?: string[];
                    };
                    /** @description The layer's rotation, scale and flip. */
                    value: {
                        /** @description Whether the layer is mirrored left to right, about its centre and before its rotation. */
                        flipX?: boolean;
                        /** @description Whether the layer is mirrored top to bottom, about its centre and before its rotation. */
                        flipY?: boolean;
                        /** @description Rotation about the layer's anchor, in degrees, clockwise. */
                        rotationDeg: number;
                        /** @description Scale of the layer; 1 is as authored. */
                        scale: number;
                    };
                };
                /** @enum {string} */
                type: "text";
                /**
                 * @description true lays spot varnish exactly where the layer is, on a machine that varnishes; it still prints in colour.
                 * @enum {boolean}
                 */
                varnish?: true;
                /** @description The layer's width as a fraction of the reference's width. Positive; uncapped, so above 1 hangs over the edge and is clipped. */
                wFrac: number;
                /** @description Paint depth, lowest painted first. A multiple of 10 follows the layer's place in the list; any other value pins it. */
                z: number;
            } | {
                /** @description The point of the reference the layer is placed against, and the layer's own matching point: top-left puts the layer's top-left corner on the reference's. */
                anchor: string;
                /** @description Another layer's id, to place and size this one against that layer's box instead of the plate. A missing layer falls back to the plate. */
                anchorTo?: string;
                /** @description How it mixes with the layers under it, per ink. Absent is normal. */
                blend?: string;
                /** @description The layer's height as a fraction of the reference's height. Positive; uncapped, so above 1 hangs over the edge and is clipped. */
                hFrac: number;
                /** @description The layer's id: what anchorTo, groups and a customer's values name it by. Never changes. */
                id: string;
                /**
                 * @description true locks the layer on the author's canvas: clicks pass through and it cannot be deleted. Absent is unlocked.
                 * @enum {boolean}
                 */
                locked?: true;
                /** @description A backdrop painted behind this layer's content at exactly its box: a colour, or a filled shape. Text and image layers only. */
                mat?: {
                    /** @description The backdrop's colour. */
                    color: {
                        /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                        cmyk: [
                            number,
                            number,
                            number,
                            number
                        ];
                    } | {
                        /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                        spot: {
                            /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                            fallback: {
                                /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                cmyk: [
                                    number,
                                    number,
                                    number,
                                    number
                                ];
                            };
                            /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                            name: string;
                            /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                            preview?: {
                                /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                rgb: [
                                    number,
                                    number,
                                    number
                                ];
                            };
                        };
                    } | {
                        /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                        ink: string;
                    } | {
                        /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                        entry: string;
                        /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                        palette: string;
                    };
                    /**
                     * @description color is a plain backdrop; shape fills a silhouette.
                     * @enum {string}
                     */
                    kind: "color";
                } | {
                    /** @description The silhouette's colour. */
                    fill: {
                        /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                        cmyk: [
                            number,
                            number,
                            number,
                            number
                        ];
                    } | {
                        /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                        spot: {
                            /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                            fallback: {
                                /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                cmyk: [
                                    number,
                                    number,
                                    number,
                                    number
                                ];
                            };
                            /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                            name: string;
                            /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                            preview?: {
                                /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                rgb: [
                                    number,
                                    number,
                                    number
                                ];
                            };
                        };
                    } | {
                        /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                        ink: string;
                    } | {
                        /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                        entry: string;
                        /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                        palette: string;
                    };
                    /**
                     * @description color is a plain backdrop; shape fills a silhouette.
                     * @enum {string}
                     */
                    kind: "shape";
                    /** @description The backdrop's silhouette, at the layer's box. */
                    shape: {
                        /** @description SVG path data in fractions of its box, (0,0) its top-left and (1,1) its bottom-right: `M 0 0 L 1 0 L 1 1 L 0 1 Z` is the whole box. No arcs. */
                        dFrac: string;
                        /**
                         * @description Inline path geometry.
                         * @enum {string}
                         */
                        type: "path";
                    } | {
                        /** @description The shape's id, `shp_…`, as list_shapes returns it. */
                        shapeId: string;
                        /**
                         * @description One of the tenant's shapes, by id.
                         * @enum {string}
                         */
                        type: "shape";
                    };
                };
                /** @description What the author reads the layer as. Not unique; absent, the layer reads as its id. */
                name?: string;
                /** @description How far the layer sits from its anchor, as fractions of the reference, always toward the reference's centre: { x: 0.05, y: 0.05 } nudges it 5 % in from any corner. Ignored on a centred axis. */
                offsetFrac: {
                    /** @description Across, as a fraction of the reference's width: 0.05 is 5 %. Toward the centre; negative pushes outward. Uncapped. */
                    x: number;
                    /** @description Down or up, as a fraction of the reference's height: 0.05 is 5 %. Toward the centre; negative pushes outward. Uncapped. */
                    y: number;
                };
                /** @description The layer's opacity, which a customer may be offered. Absent is full and not offered. */
                opacity?: {
                    /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                    constraints?: {
                        /** @description The most opacity a customer may choose, 0.01 to 1. */
                        max?: number;
                        /** @description The least opacity a customer may choose, 0.01 to 1. */
                        min?: number;
                        /** @description The step between choosable opacities, e.g. 0.05. */
                        step?: number;
                    };
                    /** @description A hint shown to the customer under the attribute's field. */
                    description?: string;
                    /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                    editable: boolean;
                    /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                    fieldKey?: string;
                    /** @description What a customer reads the attribute as, when editable. */
                    label?: string;
                    /** @description How opaque the whole layer is: 1 is full, 0.01 the least. */
                    value: number;
                };
                /**
                 * @description false makes it a guide layer: laid out and drawn on the author's canvas, never printed or shown to a customer. Absent prints.
                 * @enum {boolean}
                 */
                print?: false;
                props: {
                    /** @description How much lighter (up to 1) or darker (down to -1) the photo is drawn; absent or 0 is as uploaded. */
                    brightness?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most value a customer may choose. */
                            max?: number;
                            /** @description The least value a customer may choose. */
                            min?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The step between the values a customer may choose. */
                            step?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: number;
                    };
                    /** @description How far the photo's tones are pushed apart (up to 1) or pulled toward middle grey (down to -1); absent or 0 is as uploaded. */
                    contrast?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most value a customer may choose. */
                            max?: number;
                            /** @description The least value a customer may choose. */
                            min?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The step between the values a customer may choose. */
                            step?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: number;
                    };
                    /** @description How round the picture's corners are: their radius as a fraction of the shorter side of the layer's box, 0 (square) to 0.5 (a square box becomes a circle). The outline and the shadow follow it. */
                    cornerRadiusShortSide?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most value a customer may choose. */
                            max?: number;
                            /** @description The least value a customer may choose. */
                            min?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The step between the values a customer may choose. */
                            step?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: number;
                    };
                    /** @description Where the picture sits in its frame, under cover. Absent is uncropped. */
                    crop?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most zoom a customer may choose; absent is 3. */
                            maxZoom?: number;
                            /** @description The least zoom a customer may choose; absent is 1. */
                            minZoom?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: {
                            /** @description How far the picture's centre sits right of the frame's centre, in frame widths: 0.1 is a tenth of the frame. Clamped so the picture always covers the frame, never refused. */
                            xFrac: number;
                            /** @description How far the picture's centre sits below the frame's centre, in frame heights: 0.1 is a tenth of the frame. Clamped so the picture always covers the frame, never refused. */
                            yFrac: number;
                            /** @description The picture's scale over what cover gives it: 1 is the picture just covering the frame, up to 5. */
                            zoom: number;
                        };
                    };
                    /** @description The colour a duotone photo's lightest tones become; absent is paper white. A process colour: a spot ink is refused. */
                    duotoneHighlight?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /**
                             * @description true lets a customer choose any colour, beside or instead of a palette.
                             * @enum {boolean}
                             */
                            anyColor: true;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                            palette: string;
                        } | {
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                            palette?: string;
                        } | {
                            /**
                             * @description true lets a customer choose any colour, beside or instead of a palette.
                             * @enum {boolean}
                             */
                            anyColor: true;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: {
                            /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                            cmyk: [
                                number,
                                number,
                                number,
                                number
                            ];
                        } | {
                            /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                            spot: {
                                /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                fallback: {
                                    /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                    cmyk: [
                                        number,
                                        number,
                                        number,
                                        number
                                    ];
                                };
                                /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                name: string;
                                /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                preview?: {
                                    /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                    rgb: [
                                        number,
                                        number,
                                        number
                                    ];
                                };
                            };
                        } | {
                            /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                            ink: string;
                        } | {
                            /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                            entry: string;
                            /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                            palette: string;
                        };
                    };
                    /** @description The colour a duotone photo's darkest tones become; absent is black. A process colour: a spot ink is refused. */
                    duotoneShadow?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /**
                             * @description true lets a customer choose any colour, beside or instead of a palette.
                             * @enum {boolean}
                             */
                            anyColor: true;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                            palette: string;
                        } | {
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                            palette?: string;
                        } | {
                            /**
                             * @description true lets a customer choose any colour, beside or instead of a palette.
                             * @enum {boolean}
                             */
                            anyColor: true;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: {
                            /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                            cmyk: [
                                number,
                                number,
                                number,
                                number
                            ];
                        } | {
                            /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                            spot: {
                                /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                fallback: {
                                    /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                    cmyk: [
                                        number,
                                        number,
                                        number,
                                        number
                                    ];
                                };
                                /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                name: string;
                                /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                preview?: {
                                    /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                    rgb: [
                                        number,
                                        number,
                                        number
                                    ];
                                };
                            };
                        } | {
                            /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                            ink: string;
                        } | {
                            /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                            entry: string;
                            /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                            palette: string;
                        };
                    };
                    /** @description What the outline and the shadow are cast from: box (the layer's box, rounded by its corners) or picture (the picture's own visible pixels, so a cut-out casts its own shape). An image with a colour mat follows its box. Absent is box. */
                    effectsFollow?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: string;
                    };
                    /** @description How the picture fills its box: cover crops, contain shows it whole, fill stretches, tile repeats it. Absent is cover. */
                    fit: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: string;
                    };
                    /** @description The colour of the image's outline, whichever width draws it: absent is black under outlineWidthShortSide, and white, a sticker's edge, under outlineWidthShare. */
                    outlineColor?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /**
                             * @description true lets a customer choose any colour, beside or instead of a palette.
                             * @enum {boolean}
                             */
                            anyColor: true;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                            palette: string;
                        } | {
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                            palette?: string;
                        } | {
                            /**
                             * @description true lets a customer choose any colour, beside or instead of a palette.
                             * @enum {boolean}
                             */
                            anyColor: true;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: {
                            /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                            cmyk: [
                                number,
                                number,
                                number,
                                number
                            ];
                        } | {
                            /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                            spot: {
                                /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                fallback: {
                                    /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                    cmyk: [
                                        number,
                                        number,
                                        number,
                                        number
                                    ];
                                };
                                /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                name: string;
                                /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                preview?: {
                                    /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                    rgb: [
                                        number,
                                        number,
                                        number
                                    ];
                                };
                            };
                        } | {
                            /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                            ink: string;
                        } | {
                            /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                            entry: string;
                            /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                            palette: string;
                        };
                    };
                    /** @description The width of an outline drawn round the picture's own pixels, like a sticker's edge, as a fraction of the picture box's shorter side (0.02 is a fiftieth of it), 0 to 0.1; absent or 0 draws no outline. Not drawn on a tiled picture. An image sets this or outlineWidthShortSide, never both. */
                    outlineWidthShare?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most value a customer may choose. */
                            max?: number;
                            /** @description The least value a customer may choose. */
                            min?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The step between the values a customer may choose. */
                            step?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: number;
                    };
                    /** @description The outline's width as a fraction of the shorter side of the layer's box (0.02 is a fiftieth of it), 0 to 0.1; absent or 0 draws no outline. On an image, traced round its box or its picture (effectsFollow); an image sets this or outlineWidthShare, never both. */
                    outlineWidthShortSide?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most value a customer may choose. */
                            max?: number;
                            /** @description The least value a customer may choose. */
                            min?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The step between the values a customer may choose. */
                            step?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: number;
                    };
                    /** @description How far the photo's colours are strengthened (up to 1) or pulled toward grey (down to -1); absent or 0 is as uploaded. A tone other than none draws no colour of the photo's own, so saturation then changes nothing. */
                    saturation?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most value a customer may choose. */
                            max?: number;
                            /** @description The least value a customer may choose. */
                            min?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The step between the values a customer may choose. */
                            step?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: number;
                    };
                    /** @description How soft the shadow is: its blur radius as a fraction of the shorter side of the layer's box, 0 (sharp) to 0.25. A shadow with no offset and no blur draws nothing. */
                    shadowBlurShortSide?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most value a customer may choose. */
                            max?: number;
                            /** @description The least value a customer may choose. */
                            min?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The step between the values a customer may choose. */
                            step?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: number;
                    };
                    /** @description The colour of the shadow drawn under the layer; absent is black. */
                    shadowColor?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /**
                             * @description true lets a customer choose any colour, beside or instead of a palette.
                             * @enum {boolean}
                             */
                            anyColor: true;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                            palette: string;
                        } | {
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                            palette?: string;
                        } | {
                            /**
                             * @description true lets a customer choose any colour, beside or instead of a palette.
                             * @enum {boolean}
                             */
                            anyColor: true;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: {
                            /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                            cmyk: [
                                number,
                                number,
                                number,
                                number
                            ];
                        } | {
                            /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                            spot: {
                                /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                fallback: {
                                    /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                    cmyk: [
                                        number,
                                        number,
                                        number,
                                        number
                                    ];
                                };
                                /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                name: string;
                                /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                preview?: {
                                    /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                    rgb: [
                                        number,
                                        number,
                                        number
                                    ];
                                };
                            };
                        } | {
                            /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                            ink: string;
                        } | {
                            /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                            entry: string;
                            /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                            palette: string;
                        };
                    };
                    /** @description How far right the shadow falls, as a fraction of the shorter side of the layer's box, -0.25 to 0.25; negative is left. */
                    shadowOffsetXShortSide?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most value a customer may choose. */
                            max?: number;
                            /** @description The least value a customer may choose. */
                            min?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The step between the values a customer may choose. */
                            step?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: number;
                    };
                    /** @description How far down the shadow falls, as a fraction of the shorter side of the layer's box, -0.25 to 0.25; negative is up. */
                    shadowOffsetYShortSide?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most value a customer may choose. */
                            max?: number;
                            /** @description The least value a customer may choose. */
                            min?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The step between the values a customer may choose. */
                            step?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: number;
                    };
                    /** @description The picture's asset id; null is none chosen yet. */
                    src: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description Whether a customer may upload a picture of their own. */
                            allowUpload?: boolean;
                            /**
                             * @description true cuts a customer's upload out onto a transparent background, as a new upload in its place paid from the tenant's credits; one that fails leaves their photo as it was. Absent, never.
                             * @enum {boolean}
                             */
                            cutOut?: true;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description Whether a customer must change the template's default (a placeholder name or photo) before a design is accepted. Only on an offered text's content, image's picture, or shape's outline or fill. */
                            requireChange?: boolean;
                            /** @description Whether a customer must choose a picture. */
                            required?: boolean;
                            /** @description Present, an upload below `belowDpi` at the customer's chosen size is offered an upscale to `toDpi` before the proof, paid from the tenant's credits. Absent, never. */
                            upscale?: {
                                /** @description The print resolution, in dots per inch, below which an upload is offered an upscale. Absent, the template's minimum, else the tenant's. */
                                belowDpi?: number;
                                /** @description The print resolution, in dots per inch, an upload is upscaled to, and priced by: under `belowDpi`, at it or past it. Absent, `belowDpi`. */
                                toDpi?: number;
                            };
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: string | null;
                    };
                    /** @description The tile's size against the picture's own, when the fit is tile. */
                    tileScale?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The largest tile scale a customer may choose. */
                            max?: number;
                            /** @description The smallest tile scale a customer may choose. */
                            min?: number;
                            /** @description The step between the tile scales a customer may choose. */
                            step?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: number;
                    };
                    /** @description What the photo's lightness is mapped onto, after brightness, contrast and saturation: none (its own colours), blackAndWhite, sepia, or duotone (from duotoneShadow in its darkest tones to duotoneHighlight in its lightest). Absent is none. */
                    tone?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: string;
                    };
                };
                /** @description The layer's rotation, scale and flip, and which of them, and its position, a customer may change. */
                transform: {
                    /** @description Whether a customer may flip the layer. */
                    flip?: {
                        /** @description A hint shown to the customer under the control. */
                        description?: string;
                        /** @description Whether a customer may change it. */
                        editable: boolean;
                        /** @description What a customer reads the control as. */
                        label?: string;
                    };
                    /** @description Whether, and within what, a customer may resize the layer. */
                    resize?: {
                        /** @description A hint shown to the customer under the control. */
                        description?: string;
                        /** @description Whether a customer may change it. */
                        editable?: boolean;
                        /** @description What a customer reads the control as. */
                        label?: string;
                        /** @description The most height, in millimetres. */
                        maxHMm?: number;
                        /** @description The most width, in millimetres. */
                        maxWMm?: number;
                        /** @description The least height, in millimetres. */
                        minHMm?: number;
                        /** @description The least width, in millimetres. */
                        minWMm?: number;
                    };
                    /** @description Whether, and how far, a customer may rotate the layer. */
                    rotate: {
                        /** @description A hint shown to the customer under the control. */
                        description?: string;
                        /** @description Whether a customer may change it. */
                        editable: boolean;
                        /** @description What a customer reads the control as. */
                        label?: string;
                        /** @description The most rotation, in degrees. */
                        max?: number;
                        /** @description The least rotation, in degrees. */
                        min?: number;
                        /** @description The angle rotation snaps to, in degrees, e.g. 15. */
                        snapDeg?: number;
                    };
                    /** @description Whether, and how far, a customer may scale the layer. */
                    scale: {
                        /** @description A hint shown to the customer under the control. */
                        description?: string;
                        /** @description Whether a customer may change it. */
                        editable: boolean;
                        /** @description What a customer reads the control as. */
                        label?: string;
                        /** @description The most scale; 1 is as authored. */
                        max?: number;
                        /** @description The least scale; 1 is as authored. */
                        min?: number;
                        /** @description The step between the scales a customer may choose. */
                        step?: number;
                    };
                    /** @description Whether, and within what, a customer may move the layer. */
                    translate: {
                        /** @description Where a customer's move must keep the layer: inside the safe area (the default), the print box, or anywhere. */
                        bounds?: string;
                        /** @description A hint shown to the customer under the control. */
                        description?: string;
                        /** @description Whether a customer may change it. */
                        editable: boolean;
                        /** @description What a customer reads the control as. */
                        label?: string;
                        /** @description What a move snaps to: centre, thirds, safeEdges, layers. */
                        snapTo?: string[];
                    };
                    /** @description The layer's rotation, scale and flip. */
                    value: {
                        /** @description Whether the layer is mirrored left to right, about its centre and before its rotation. */
                        flipX?: boolean;
                        /** @description Whether the layer is mirrored top to bottom, about its centre and before its rotation. */
                        flipY?: boolean;
                        /** @description Rotation about the layer's anchor, in degrees, clockwise. */
                        rotationDeg: number;
                        /** @description Scale of the layer; 1 is as authored. */
                        scale: number;
                    };
                };
                /** @enum {string} */
                type: "image";
                /**
                 * @description true lays spot varnish exactly where the layer is, on a machine that varnishes; it still prints in colour.
                 * @enum {boolean}
                 */
                varnish?: true;
                /** @description The layer's width as a fraction of the reference's width. Positive; uncapped, so above 1 hangs over the edge and is clipped. */
                wFrac: number;
                /** @description Paint depth, lowest painted first. A multiple of 10 follows the layer's place in the list; any other value pins it. */
                z: number;
            } | {
                /** @description The point of the reference the layer is placed against, and the layer's own matching point: top-left puts the layer's top-left corner on the reference's. */
                anchor: string;
                /** @description Another layer's id, to place and size this one against that layer's box instead of the plate. A missing layer falls back to the plate. */
                anchorTo?: string;
                /** @description How it mixes with the layers under it, per ink. Absent is normal. */
                blend?: string;
                /** @description The layer's height as a fraction of the reference's height. Positive; uncapped, so above 1 hangs over the edge and is clipped. */
                hFrac: number;
                /** @description The layer's id: what anchorTo, groups and a customer's values name it by. Never changes. */
                id: string;
                /**
                 * @description true locks the layer on the author's canvas: clicks pass through and it cannot be deleted. Absent is unlocked.
                 * @enum {boolean}
                 */
                locked?: true;
                /** @description What the author reads the layer as. Not unique; absent, the layer reads as its id. */
                name?: string;
                /** @description How far the layer sits from its anchor, as fractions of the reference, always toward the reference's centre: { x: 0.05, y: 0.05 } nudges it 5 % in from any corner. Ignored on a centred axis. */
                offsetFrac: {
                    /** @description Across, as a fraction of the reference's width: 0.05 is 5 %. Toward the centre; negative pushes outward. Uncapped. */
                    x: number;
                    /** @description Down or up, as a fraction of the reference's height: 0.05 is 5 %. Toward the centre; negative pushes outward. Uncapped. */
                    y: number;
                };
                /** @description The layer's opacity, which a customer may be offered. Absent is full and not offered. */
                opacity?: {
                    /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                    constraints?: {
                        /** @description The most opacity a customer may choose, 0.01 to 1. */
                        max?: number;
                        /** @description The least opacity a customer may choose, 0.01 to 1. */
                        min?: number;
                        /** @description The step between choosable opacities, e.g. 0.05. */
                        step?: number;
                    };
                    /** @description A hint shown to the customer under the attribute's field. */
                    description?: string;
                    /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                    editable: boolean;
                    /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                    fieldKey?: string;
                    /** @description What a customer reads the attribute as, when editable. */
                    label?: string;
                    /** @description How opaque the whole layer is: 1 is full, 0.01 the least. */
                    value: number;
                };
                /**
                 * @description false makes it a guide layer: laid out and drawn on the author's canvas, never printed or shown to a customer. Absent prints.
                 * @enum {boolean}
                 */
                print?: false;
                props: {
                    /** @description Where the picture sits in its frame, under cover. Absent is uncropped. */
                    crop?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most zoom a customer may choose; absent is 3. */
                            maxZoom?: number;
                            /** @description The least zoom a customer may choose; absent is 1. */
                            minZoom?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: {
                            /** @description How far the picture's centre sits right of the frame's centre, in frame widths: 0.1 is a tenth of the frame. Clamped so the picture always covers the frame, never refused. */
                            xFrac: number;
                            /** @description How far the picture's centre sits below the frame's centre, in frame heights: 0.1 is a tenth of the frame. Clamped so the picture always covers the frame, never refused. */
                            yFrac: number;
                            /** @description The picture's scale over what cover gives it: 1 is the picture just covering the frame, up to 5. */
                            zoom: number;
                        };
                    };
                    /** @description What the silhouette is painted with: a colour, a gradient across its box, or a picture clipped to it. */
                    fill: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description Whether a customer may upload a picture of their own. */
                            allowUpload?: boolean;
                            /**
                             * @description true lets a customer choose any colour, beside or instead of a palette.
                             * @enum {boolean}
                             */
                            anyColor?: true;
                            /**
                             * @description true cuts a customer's upload out onto a transparent background, as a new upload in its place paid from the tenant's credits; one that fails leaves their photo as it was. Absent, never.
                             * @enum {boolean}
                             */
                            cutOut?: true;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                            palette?: string;
                            /** @description Whether a customer must change the template's default (a placeholder name or photo) before a design is accepted. Only on an offered text's content, image's picture, or shape's outline or fill. */
                            requireChange?: boolean;
                            /** @description Whether a customer must choose a picture. */
                            required?: boolean;
                            /** @description Present, an upload below `belowDpi` at the customer's chosen size is offered an upscale to `toDpi` before the proof, paid from the tenant's credits. Absent, never. */
                            upscale?: {
                                /** @description The print resolution, in dots per inch, below which an upload is offered an upscale. Absent, the template's minimum, else the tenant's. */
                                belowDpi?: number;
                                /** @description The print resolution, in dots per inch, an upload is upscaled to, and priced by: under `belowDpi`, at it or past it. Absent, `belowDpi`. */
                                toDpi?: number;
                            };
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: {
                            /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                            cmyk: [
                                number,
                                number,
                                number,
                                number
                            ];
                        } | {
                            /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                            spot: {
                                /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                fallback: {
                                    /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                    cmyk: [
                                        number,
                                        number,
                                        number,
                                        number
                                    ];
                                };
                                /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                name: string;
                                /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                preview?: {
                                    /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                    rgb: [
                                        number,
                                        number,
                                        number
                                    ];
                                };
                            };
                        } | {
                            /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                            ink: string;
                        } | {
                            /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                            entry: string;
                            /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                            palette: string;
                        } | {
                            /** @description linear crosses a shape's box or text's letters at an angle; radial from the centre to the farthest corner. */
                            gradient: {
                                /** @description The direction the colours run, in degrees clockwise from straight up: 90 runs left to right, 180 top to bottom. It spans a shape's box or a text's letters. */
                                angleDeg: number;
                                /** @enum {string} */
                                kind: "linear";
                                /** @description The gradient's colours, 2 to 8, in order of position. Blended in CMYK, as the print blends them. */
                                stops: {
                                    /** @description Where the colour sits along the gradient: 0 is its start, 1 its end. Stops are in order; two at one position make a hard edge. */
                                    at: number;
                                    /** @description The colour at this stop: a CMYK colour, one of your inks, or a palette entry. A spot ink cannot be one: a gradient blends process colours. */
                                    color: {
                                        /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                        cmyk: [
                                            number,
                                            number,
                                            number,
                                            number
                                        ];
                                    } | {
                                        /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                                        spot: {
                                            /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                            fallback: {
                                                /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                                cmyk: [
                                                    number,
                                                    number,
                                                    number,
                                                    number
                                                ];
                                            };
                                            /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                            name: string;
                                            /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                            preview?: {
                                                /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                                rgb: [
                                                    number,
                                                    number,
                                                    number
                                                ];
                                            };
                                        };
                                    } | {
                                        /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                        ink: string;
                                    } | {
                                        /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                                        entry: string;
                                        /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                                        palette: string;
                                    };
                                }[];
                            } | {
                                /** @enum {string} */
                                kind: "radial";
                                /** @description The gradient's colours, 2 to 8, in order of position. Blended in CMYK, as the print blends them. */
                                stops: {
                                    /** @description Where the colour sits along the gradient: 0 is its start, 1 its end. Stops are in order; two at one position make a hard edge. */
                                    at: number;
                                    /** @description The colour at this stop: a CMYK colour, one of your inks, or a palette entry. A spot ink cannot be one: a gradient blends process colours. */
                                    color: {
                                        /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                        cmyk: [
                                            number,
                                            number,
                                            number,
                                            number
                                        ];
                                    } | {
                                        /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                                        spot: {
                                            /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                            fallback: {
                                                /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                                cmyk: [
                                                    number,
                                                    number,
                                                    number,
                                                    number
                                                ];
                                            };
                                            /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                            name: string;
                                            /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                            preview?: {
                                                /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                                rgb: [
                                                    number,
                                                    number,
                                                    number
                                                ];
                                            };
                                        };
                                    } | {
                                        /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                        ink: string;
                                    } | {
                                        /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                                        entry: string;
                                        /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                                        palette: string;
                                    };
                                }[];
                            };
                        } | {
                            /** @description A picture's asset id, clipped to the shape; empty while none is chosen. */
                            imageAssetId: string;
                        };
                    };
                    /** @description How the picture fills its box: cover crops, contain shows it whole, fill stretches, tile repeats it. Absent is cover. */
                    fit?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: string;
                    };
                    /** @description The colour of the line drawn around the layer's edge, outside it; absent is black. */
                    outlineColor?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /**
                             * @description true lets a customer choose any colour, beside or instead of a palette.
                             * @enum {boolean}
                             */
                            anyColor: true;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                            palette: string;
                        } | {
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                            palette?: string;
                        } | {
                            /**
                             * @description true lets a customer choose any colour, beside or instead of a palette.
                             * @enum {boolean}
                             */
                            anyColor: true;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: {
                            /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                            cmyk: [
                                number,
                                number,
                                number,
                                number
                            ];
                        } | {
                            /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                            spot: {
                                /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                fallback: {
                                    /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                    cmyk: [
                                        number,
                                        number,
                                        number,
                                        number
                                    ];
                                };
                                /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                name: string;
                                /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                preview?: {
                                    /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                    rgb: [
                                        number,
                                        number,
                                        number
                                    ];
                                };
                            };
                        } | {
                            /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                            ink: string;
                        } | {
                            /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                            entry: string;
                            /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                            palette: string;
                        };
                    };
                    /** @description The outline's width as a fraction of the shorter side of the layer's box (0.02 is a fiftieth of it), 0 to 0.1; absent or 0 draws no outline. On an image, traced round its box or its picture (effectsFollow); an image sets this or outlineWidthShare, never both. */
                    outlineWidthShortSide?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most value a customer may choose. */
                            max?: number;
                            /** @description The least value a customer may choose. */
                            min?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The step between the values a customer may choose. */
                            step?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: number;
                    };
                    /** @description How soft the shadow is: its blur radius as a fraction of the shorter side of the layer's box, 0 (sharp) to 0.25. A shadow with no offset and no blur draws nothing. */
                    shadowBlurShortSide?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most value a customer may choose. */
                            max?: number;
                            /** @description The least value a customer may choose. */
                            min?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The step between the values a customer may choose. */
                            step?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: number;
                    };
                    /** @description The colour of the shadow drawn under the layer; absent is black. */
                    shadowColor?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /**
                             * @description true lets a customer choose any colour, beside or instead of a palette.
                             * @enum {boolean}
                             */
                            anyColor: true;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                            palette: string;
                        } | {
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                            palette?: string;
                        } | {
                            /**
                             * @description true lets a customer choose any colour, beside or instead of a palette.
                             * @enum {boolean}
                             */
                            anyColor: true;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: {
                            /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                            cmyk: [
                                number,
                                number,
                                number,
                                number
                            ];
                        } | {
                            /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                            spot: {
                                /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                fallback: {
                                    /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                    cmyk: [
                                        number,
                                        number,
                                        number,
                                        number
                                    ];
                                };
                                /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                name: string;
                                /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                preview?: {
                                    /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                    rgb: [
                                        number,
                                        number,
                                        number
                                    ];
                                };
                            };
                        } | {
                            /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                            ink: string;
                        } | {
                            /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                            entry: string;
                            /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                            palette: string;
                        };
                    };
                    /** @description How far right the shadow falls, as a fraction of the shorter side of the layer's box, -0.25 to 0.25; negative is left. */
                    shadowOffsetXShortSide?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most value a customer may choose. */
                            max?: number;
                            /** @description The least value a customer may choose. */
                            min?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The step between the values a customer may choose. */
                            step?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: number;
                    };
                    /** @description How far down the shadow falls, as a fraction of the shorter side of the layer's box, -0.25 to 0.25; negative is up. */
                    shadowOffsetYShortSide?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most value a customer may choose. */
                            max?: number;
                            /** @description The least value a customer may choose. */
                            min?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The step between the values a customer may choose. */
                            step?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: number;
                    };
                    /** @description The layer's silhouette: inline geometry or one of the tenant's shapes. */
                    shape: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /**
                             * @description true lets a customer choose no shape at all.
                             * @enum {boolean}
                             */
                            allowEmpty?: true;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description Whether a customer must change the template's default (a placeholder name or photo) before a design is accepted. Only on an offered text's content, image's picture, or shape's outline or fill. */
                            requireChange?: boolean;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: {
                            /** @description SVG path data in fractions of its box, (0,0) its top-left and (1,1) its bottom-right: `M 0 0 L 1 0 L 1 1 L 0 1 Z` is the whole box. No arcs. */
                            dFrac: string;
                            /**
                             * @description Inline path geometry.
                             * @enum {string}
                             */
                            type: "path";
                        } | {
                            /** @description The shape's id, `shp_…`, as list_shapes returns it. */
                            shapeId: string;
                            /**
                             * @description One of the tenant's shapes, by id.
                             * @enum {string}
                             */
                            type: "shape";
                        };
                    };
                    /** @description The tile's size against the picture's own, when the fit is tile. */
                    tileScale?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The largest tile scale a customer may choose. */
                            max?: number;
                            /** @description The smallest tile scale a customer may choose. */
                            min?: number;
                            /** @description The step between the tile scales a customer may choose. */
                            step?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: number;
                    };
                };
                /** @description The layer's rotation, scale and flip, and which of them, and its position, a customer may change. */
                transform: {
                    /** @description Whether a customer may flip the layer. */
                    flip?: {
                        /** @description A hint shown to the customer under the control. */
                        description?: string;
                        /** @description Whether a customer may change it. */
                        editable: boolean;
                        /** @description What a customer reads the control as. */
                        label?: string;
                    };
                    /** @description Whether, and within what, a customer may resize the layer. */
                    resize?: {
                        /** @description A hint shown to the customer under the control. */
                        description?: string;
                        /** @description Whether a customer may change it. */
                        editable?: boolean;
                        /** @description What a customer reads the control as. */
                        label?: string;
                        /** @description The most height, in millimetres. */
                        maxHMm?: number;
                        /** @description The most width, in millimetres. */
                        maxWMm?: number;
                        /** @description The least height, in millimetres. */
                        minHMm?: number;
                        /** @description The least width, in millimetres. */
                        minWMm?: number;
                    };
                    /** @description Whether, and how far, a customer may rotate the layer. */
                    rotate: {
                        /** @description A hint shown to the customer under the control. */
                        description?: string;
                        /** @description Whether a customer may change it. */
                        editable: boolean;
                        /** @description What a customer reads the control as. */
                        label?: string;
                        /** @description The most rotation, in degrees. */
                        max?: number;
                        /** @description The least rotation, in degrees. */
                        min?: number;
                        /** @description The angle rotation snaps to, in degrees, e.g. 15. */
                        snapDeg?: number;
                    };
                    /** @description Whether, and how far, a customer may scale the layer. */
                    scale: {
                        /** @description A hint shown to the customer under the control. */
                        description?: string;
                        /** @description Whether a customer may change it. */
                        editable: boolean;
                        /** @description What a customer reads the control as. */
                        label?: string;
                        /** @description The most scale; 1 is as authored. */
                        max?: number;
                        /** @description The least scale; 1 is as authored. */
                        min?: number;
                        /** @description The step between the scales a customer may choose. */
                        step?: number;
                    };
                    /** @description Whether, and within what, a customer may move the layer. */
                    translate: {
                        /** @description Where a customer's move must keep the layer: inside the safe area (the default), the print box, or anywhere. */
                        bounds?: string;
                        /** @description A hint shown to the customer under the control. */
                        description?: string;
                        /** @description Whether a customer may change it. */
                        editable: boolean;
                        /** @description What a customer reads the control as. */
                        label?: string;
                        /** @description What a move snaps to: centre, thirds, safeEdges, layers. */
                        snapTo?: string[];
                    };
                    /** @description The layer's rotation, scale and flip. */
                    value: {
                        /** @description Whether the layer is mirrored left to right, about its centre and before its rotation. */
                        flipX?: boolean;
                        /** @description Whether the layer is mirrored top to bottom, about its centre and before its rotation. */
                        flipY?: boolean;
                        /** @description Rotation about the layer's anchor, in degrees, clockwise. */
                        rotationDeg: number;
                        /** @description Scale of the layer; 1 is as authored. */
                        scale: number;
                    };
                };
                /** @enum {string} */
                type: "shape";
                /**
                 * @description true lays spot varnish exactly where the layer is, on a machine that varnishes; it still prints in colour.
                 * @enum {boolean}
                 */
                varnish?: true;
                /** @description The layer's width as a fraction of the reference's width. Positive; uncapped, so above 1 hangs over the edge and is clipped. */
                wFrac: number;
                /** @description Paint depth, lowest painted first. A multiple of 10 follows the layer's place in the list; any other value pins it. */
                z: number;
            })[];
            name: string;
            /** @description Colours the template offers as its own, by name: a palette offer names one by that name. A stored template holds one only where a library palette it offered was deleted; a published template as served holds every palette it offers. */
            palettes?: {
                [key: string]: {
                    /** @description The colour. */
                    color: {
                        /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                        cmyk: [
                            number,
                            number,
                            number,
                            number
                        ];
                    } | {
                        /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                        spot: {
                            /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                            fallback: {
                                /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                cmyk: [
                                    number,
                                    number,
                                    number,
                                    number
                                ];
                            };
                            /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                            name: string;
                            /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                            preview?: {
                                /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                rgb: [
                                    number,
                                    number,
                                    number
                                ];
                            };
                        };
                    } | {
                        /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                        ink: string;
                    };
                    /** @description The name a customer picks the colour by. */
                    name: string;
                }[];
            };
            /** @description The artwork's aspect ratio as two positive numbers ({ w: 3, h: 2 } is landscape): the shape of the plate every fraction is of. */
            ratio: {
                /** @description The ratio's height part. Positive. */
                h: number;
                /** @description The ratio's width part. Positive. */
                w: number;
            };
            /** @description How far, as a fraction of the ratio, a print size may differ from it: 0.02 is 2 %. 0 or more. */
            ratioTolerance: number;
            /** @description The die-cut outline the print is cut to, which a customer may be offered. Absent is a square-cornered rectangle. */
            shape?: {
                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                constraints?: {
                    /**
                     * @description true lets a customer choose no shape at all.
                     * @enum {boolean}
                     */
                    allowEmpty?: true;
                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                    oneOf?: string[];
                    /** @description Whether a customer must change the template's default (a placeholder name or photo) before a design is accepted. Only on an offered text's content, image's picture, or shape's outline or fill. */
                    requireChange?: boolean;
                };
                /** @description A hint shown to the customer under the attribute's field. */
                description?: string;
                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                editable: boolean;
                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                fieldKey?: string;
                /** @description What a customer reads the attribute as, when editable. */
                label?: string;
                /** @description The attribute's value, as the template stores it. */
                value: {
                    /** @description SVG path data in fractions of its box, (0,0) its top-left and (1,1) its bottom-right: `M 0 0 L 1 0 L 1 1 L 0 1 Z` is the whole box. No arcs. */
                    dFrac: string;
                    /**
                     * @description Inline path geometry.
                     * @enum {string}
                     */
                    type: "path";
                } | {
                    /** @description The shape's id, `shp_…`, as list_shapes returns it. */
                    shapeId: string;
                    /**
                     * @description One of the tenant's shapes, by id.
                     * @enum {string}
                     */
                    type: "shape";
                };
            };
            /** @description What a customer's moves snap to, and the author's grid. */
            snap?: {
                /** @description The author's grid, which the author's drags snap to. A customer never sees it. */
                grid?: {
                    /** @description The grid's step as a fraction of the plate, 0.01 to 0.5: 0.05 is a line every 5 %. */
                    stepFrac: number;
                };
                /** @description What a move snaps to: centre, thirds, safeEdges, layers. */
                targets?: string[];
            };
            tenantId: string;
            uploads?: {
                /** @description The file formats a customer may upload, each once: png, jpeg, webp, heic. Absent, all of them. */
                formats?: string[];
                /** @description The largest upload, in bytes, at most 83886080. Absent, that. */
                maxBytes?: number;
                /** @description The minimum print resolution a design's pictures are judged against where they print, in dots per inch, at most 1200. Absent, the tenant's. */
                minDpi?: number;
            };
            version: number;
        };
        RunCancelledEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                runId: string;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "run.cancelled";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        RunCompletedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                runId: string;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "run.completed";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        RunExhaustedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                reason: string;
                runId: string;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "run.exhausted";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        RunFailedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                reason: string;
                runId: string;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "run.failed";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        RunStartedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                runId: string;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "run.started";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        ShapeCreatedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                shapeId: string;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "shape.created";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        ShapeDeletedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                shapeId: string;
                shapeName: string;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "shape.deleted";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        ShapeUpdatedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                fields: string[];
                shapeId: string;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "shape.updated";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        ShareLinkRegeneratedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                by: string;
                kind: string;
                linkId: string;
                name: string | null;
                subjectId: string;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "share_link.regenerated";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        ShareLinkRevokedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                by: string;
                kind: string;
                linkId: string;
                name: string | null;
                subjectId: string;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "share_link.revoked";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        TemplateDeletedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                baseId: string;
                wasLive: boolean;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "template.deleted";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        TemplateInput: {
            /** @description What is painted behind every layer, across the bleed. Absent is none. */
            background?: {
                /** @description The background colour. */
                color: {
                    /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                    constraints?: {
                        /**
                         * @description true lets a customer choose any colour, beside or instead of a palette.
                         * @enum {boolean}
                         */
                        anyColor: true;
                        /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                        oneOf?: string[];
                        /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                        palette: string;
                    } | {
                        /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                        oneOf?: string[];
                        /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                        palette?: string;
                    } | {
                        /**
                         * @description true lets a customer choose any colour, beside or instead of a palette.
                         * @enum {boolean}
                         */
                        anyColor: true;
                        /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                        oneOf?: string[];
                    };
                    /** @description A hint shown to the customer under the attribute's field. */
                    description?: string;
                    /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                    editable: boolean;
                    /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                    fieldKey?: string;
                    /** @description What a customer reads the attribute as, when editable. */
                    label?: string;
                    /** @description The attribute's value, as the template stores it. */
                    value: {
                        /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                        cmyk: [
                            number,
                            number,
                            number,
                            number
                        ];
                    } | {
                        /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                        spot: {
                            /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                            fallback: {
                                /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                cmyk: [
                                    number,
                                    number,
                                    number,
                                    number
                                ];
                            };
                            /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                            name: string;
                            /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                            preview?: {
                                /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                rgb: [
                                    number,
                                    number,
                                    number
                                ];
                            };
                        };
                    } | {
                        /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                        ink: string;
                    } | {
                        /** @description An older spelling of an ink reference; send `{ ink }`. */
                        spot: {
                            /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                            ink: string;
                        };
                    } | {
                        /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                        entry: string;
                        /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                        palette: string;
                    };
                };
                /**
                 * @description color paints the whole artwork, bleed included; image fills it with a picture.
                 * @enum {string}
                 */
                kind: "color";
            } | {
                /** @description Where the picture sits in its frame, under cover. Absent is uncropped. */
                crop?: {
                    /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                    constraints?: {
                        /** @description The most zoom a customer may choose; absent is 3. */
                        maxZoom?: number;
                        /** @description The least zoom a customer may choose; absent is 1. */
                        minZoom?: number;
                    };
                    /** @description A hint shown to the customer under the attribute's field. */
                    description?: string;
                    /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                    editable: boolean;
                    /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                    fieldKey?: string;
                    /** @description What a customer reads the attribute as, when editable. */
                    label?: string;
                    /** @description The attribute's value, as the template stores it. */
                    value: {
                        /** @description How far the picture's centre sits right of the frame's centre, in frame widths: 0.1 is a tenth of the frame. Clamped so the picture always covers the frame, never refused. */
                        xFrac: number;
                        /** @description How far the picture's centre sits below the frame's centre, in frame heights: 0.1 is a tenth of the frame. Clamped so the picture always covers the frame, never refused. */
                        yFrac: number;
                        /** @description The picture's scale over what cover gives it: 1 is the picture just covering the frame, up to 5. */
                        zoom: number;
                    };
                };
                /** @description How the picture fills its box: cover crops, contain shows it whole, fill stretches, tile repeats it. Absent is cover. */
                fit?: {
                    /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                    constraints?: {
                        /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                        oneOf?: string[];
                    };
                    /** @description A hint shown to the customer under the attribute's field. */
                    description?: string;
                    /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                    editable: boolean;
                    /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                    fieldKey?: string;
                    /** @description What a customer reads the attribute as, when editable. */
                    label?: string;
                    /**
                     * @description The attribute's value, as the template stores it.
                     * @enum {string}
                     */
                    value: "contain" | "cover" | "fill" | "tile";
                };
                /** @description The background picture's asset id. */
                imageAssetId: {
                    /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                    constraints?: {
                        /** @description Whether a customer may upload a picture of their own. */
                        allowUpload?: boolean;
                        /**
                         * @description true cuts a customer's upload out onto a transparent background, as a new upload in its place paid from the tenant's credits; one that fails leaves their photo as it was. Absent, never.
                         * @enum {boolean}
                         */
                        cutOut?: true;
                        /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                        oneOf?: string[];
                        /** @description Whether a customer must change the template's default (a placeholder name or photo) before a design is accepted. Only on an offered text's content, image's picture, or shape's outline or fill. */
                        requireChange?: boolean;
                        /** @description Whether a customer must choose a picture. */
                        required?: boolean;
                        /** @description Present, an upload below `belowDpi` at the customer's chosen size is offered an upscale to `toDpi` before the proof, paid from the tenant's credits. Absent, never. */
                        upscale?: {
                            /** @description The print resolution, in dots per inch, below which an upload is offered an upscale. Absent, the template's minimum, else the tenant's. */
                            belowDpi?: number;
                            /** @description The print resolution, in dots per inch, an upload is upscaled to, and priced by: under `belowDpi`, at it or past it. Absent, `belowDpi`. */
                            toDpi?: number;
                        };
                    };
                    /** @description A hint shown to the customer under the attribute's field. */
                    description?: string;
                    /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                    editable: boolean;
                    /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                    fieldKey?: string;
                    /** @description What a customer reads the attribute as, when editable. */
                    label?: string;
                    /** @description The attribute's value, as the template stores it. */
                    value: string;
                };
                /**
                 * @description color paints the whole artwork, bleed included; image fills it with a picture.
                 * @enum {string}
                 */
                kind: "image";
                /** @description The tile's size against the picture's own, when the fit is tile. */
                tileScale?: {
                    /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                    constraints?: {
                        /** @description The largest tile scale a customer may choose. */
                        max?: number;
                        /** @description The smallest tile scale a customer may choose. */
                        min?: number;
                        /** @description The step between the tile scales a customer may choose. */
                        step?: number;
                    };
                    /** @description A hint shown to the customer under the attribute's field. */
                    description?: string;
                    /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                    editable: boolean;
                    /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                    fieldKey?: string;
                    /** @description What a customer reads the attribute as, when editable. */
                    label?: string;
                    /** @description The attribute's value, as the template stores it. */
                    value: number;
                };
            };
            /**
             * @description Which of nine points, top-left to bottom-right, a cover crop keeps; read only when fit is cover. Absent is center.
             * @enum {string}
             */
            coverAlign?: "top-left" | "top-center" | "top-right" | "center-left" | "center" | "center-right" | "bottom-left" | "bottom-center" | "bottom-right";
            /** @description The layers a customer may add of their own, per kind: how many, and the preset each starts as. Added layers paint above the template's layers and belong to no group. */
            customerLayers?: {
                /** @description Whether, and how, a customer may add image layers. */
                image?: {
                    /** @description The preset every added image layer starts as: a image layer without id, name, z, anchorTo, locked or print. What it offers is what a customer may change on the layers they add. */
                    layer: {
                        /**
                         * @description The point of the reference the layer is placed against, and the layer's own matching point: top-left puts the layer's top-left corner on the reference's.
                         * @enum {string}
                         */
                        anchor: "top-left" | "top-center" | "top-right" | "center-left" | "center" | "center-right" | "bottom-left" | "bottom-center" | "bottom-right";
                        /**
                         * @description How it mixes with the layers under it, per ink. Absent is normal.
                         * @enum {string}
                         */
                        blend?: "multiply" | "screen" | "overlay" | "darken" | "lighten";
                        /** @description The layer's height as a fraction of the reference's height. Positive; uncapped, so above 1 hangs over the edge and is clipped. */
                        hFrac: number;
                        /** @description A backdrop painted behind this layer's content at exactly its box: a colour, or a filled shape. Text and image layers only. */
                        mat?: {
                            /** @description The backdrop's colour. */
                            color: {
                                /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                cmyk: [
                                    number,
                                    number,
                                    number,
                                    number
                                ];
                            } | {
                                /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                                spot: {
                                    /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                    fallback: {
                                        /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                        cmyk: [
                                            number,
                                            number,
                                            number,
                                            number
                                        ];
                                    };
                                    /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                    name: string;
                                    /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                    preview?: {
                                        /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                        rgb: [
                                            number,
                                            number,
                                            number
                                        ];
                                    };
                                };
                            } | {
                                /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                ink: string;
                            } | {
                                /** @description An older spelling of an ink reference; send `{ ink }`. */
                                spot: {
                                    /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                    ink: string;
                                };
                            } | {
                                /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                                entry: string;
                                /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                                palette: string;
                            };
                            /**
                             * @description color is a plain backdrop; shape fills a silhouette.
                             * @enum {string}
                             */
                            kind: "color";
                        } | {
                            /** @description The silhouette's colour. */
                            fill: {
                                /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                cmyk: [
                                    number,
                                    number,
                                    number,
                                    number
                                ];
                            } | {
                                /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                                spot: {
                                    /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                    fallback: {
                                        /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                        cmyk: [
                                            number,
                                            number,
                                            number,
                                            number
                                        ];
                                    };
                                    /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                    name: string;
                                    /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                    preview?: {
                                        /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                        rgb: [
                                            number,
                                            number,
                                            number
                                        ];
                                    };
                                };
                            } | {
                                /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                ink: string;
                            } | {
                                /** @description An older spelling of an ink reference; send `{ ink }`. */
                                spot: {
                                    /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                    ink: string;
                                };
                            } | {
                                /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                                entry: string;
                                /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                                palette: string;
                            };
                            /**
                             * @description color is a plain backdrop; shape fills a silhouette.
                             * @enum {string}
                             */
                            kind: "shape";
                            /** @description The backdrop's silhouette, at the layer's box. */
                            shape: {
                                /** @description SVG path data in fractions of its box, (0,0) its top-left and (1,1) its bottom-right: `M 0 0 L 1 0 L 1 1 L 0 1 Z` is the whole box. No arcs. */
                                dFrac: string;
                                /**
                                 * @description Inline path geometry.
                                 * @enum {string}
                                 */
                                type: "path";
                            } | {
                                /** @description The shape's id, `shp_…`, as list_shapes returns it. */
                                shapeId: string;
                                /**
                                 * @description One of the tenant's shapes, by id.
                                 * @enum {string}
                                 */
                                type: "shape";
                            };
                        };
                        /** @description How far the layer sits from its anchor, as fractions of the reference, always toward the reference's centre: { x: 0.05, y: 0.05 } nudges it 5 % in from any corner. Ignored on a centred axis. */
                        offsetFrac: {
                            /** @description Across, as a fraction of the reference's width: 0.05 is 5 %. Toward the centre; negative pushes outward. Uncapped. */
                            x: number;
                            /** @description Down or up, as a fraction of the reference's height: 0.05 is 5 %. Toward the centre; negative pushes outward. Uncapped. */
                            y: number;
                        };
                        /** @description The layer's opacity, which a customer may be offered. Absent is full and not offered. */
                        opacity?: {
                            /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                            constraints?: {
                                /** @description The most opacity a customer may choose, 0.01 to 1. */
                                max?: number;
                                /** @description The least opacity a customer may choose, 0.01 to 1. */
                                min?: number;
                                /** @description The step between choosable opacities, e.g. 0.05. */
                                step?: number;
                            };
                            /** @description A hint shown to the customer under the attribute's field. */
                            description?: string;
                            /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                            editable: boolean;
                            /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                            fieldKey?: string;
                            /** @description What a customer reads the attribute as, when editable. */
                            label?: string;
                            /** @description How opaque the whole layer is: 1 is full, 0.01 the least. */
                            value: number;
                        };
                        props: {
                            /** @description How much lighter (up to 1) or darker (down to -1) the photo is drawn; absent or 0 is as uploaded. */
                            brightness?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most value a customer may choose. */
                                    max?: number;
                                    /** @description The least value a customer may choose. */
                                    min?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The step between the values a customer may choose. */
                                    step?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: number;
                            };
                            /** @description How far the photo's tones are pushed apart (up to 1) or pulled toward middle grey (down to -1); absent or 0 is as uploaded. */
                            contrast?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most value a customer may choose. */
                                    max?: number;
                                    /** @description The least value a customer may choose. */
                                    min?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The step between the values a customer may choose. */
                                    step?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: number;
                            };
                            /** @description How round the picture's corners are: their radius as a fraction of the shorter side of the layer's box, 0 (square) to 0.5 (a square box becomes a circle). The outline and the shadow follow it. */
                            cornerRadiusShortSide?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most value a customer may choose. */
                                    max?: number;
                                    /** @description The least value a customer may choose. */
                                    min?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The step between the values a customer may choose. */
                                    step?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: number;
                            };
                            /** @description Where the picture sits in its frame, under cover. Absent is uncropped. */
                            crop?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most zoom a customer may choose; absent is 3. */
                                    maxZoom?: number;
                                    /** @description The least zoom a customer may choose; absent is 1. */
                                    minZoom?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: {
                                    /** @description How far the picture's centre sits right of the frame's centre, in frame widths: 0.1 is a tenth of the frame. Clamped so the picture always covers the frame, never refused. */
                                    xFrac: number;
                                    /** @description How far the picture's centre sits below the frame's centre, in frame heights: 0.1 is a tenth of the frame. Clamped so the picture always covers the frame, never refused. */
                                    yFrac: number;
                                    /** @description The picture's scale over what cover gives it: 1 is the picture just covering the frame, up to 5. */
                                    zoom: number;
                                };
                            };
                            /** @description The colour a duotone photo's lightest tones become; absent is paper white. A process colour: a spot ink is refused. */
                            duotoneHighlight?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /**
                                     * @description true lets a customer choose any colour, beside or instead of a palette.
                                     * @enum {boolean}
                                     */
                                    anyColor: true;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                                    palette: string;
                                } | {
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                                    palette?: string;
                                } | {
                                    /**
                                     * @description true lets a customer choose any colour, beside or instead of a palette.
                                     * @enum {boolean}
                                     */
                                    anyColor: true;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: {
                                    /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                    cmyk: [
                                        number,
                                        number,
                                        number,
                                        number
                                    ];
                                } | {
                                    /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                                    spot: {
                                        /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                        fallback: {
                                            /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                            cmyk: [
                                                number,
                                                number,
                                                number,
                                                number
                                            ];
                                        };
                                        /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                        name: string;
                                        /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                        preview?: {
                                            /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                            rgb: [
                                                number,
                                                number,
                                                number
                                            ];
                                        };
                                    };
                                } | {
                                    /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                    ink: string;
                                } | {
                                    /** @description An older spelling of an ink reference; send `{ ink }`. */
                                    spot: {
                                        /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                        ink: string;
                                    };
                                } | {
                                    /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                                    entry: string;
                                    /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                                    palette: string;
                                };
                            };
                            /** @description The colour a duotone photo's darkest tones become; absent is black. A process colour: a spot ink is refused. */
                            duotoneShadow?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /**
                                     * @description true lets a customer choose any colour, beside or instead of a palette.
                                     * @enum {boolean}
                                     */
                                    anyColor: true;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                                    palette: string;
                                } | {
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                                    palette?: string;
                                } | {
                                    /**
                                     * @description true lets a customer choose any colour, beside or instead of a palette.
                                     * @enum {boolean}
                                     */
                                    anyColor: true;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: {
                                    /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                    cmyk: [
                                        number,
                                        number,
                                        number,
                                        number
                                    ];
                                } | {
                                    /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                                    spot: {
                                        /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                        fallback: {
                                            /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                            cmyk: [
                                                number,
                                                number,
                                                number,
                                                number
                                            ];
                                        };
                                        /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                        name: string;
                                        /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                        preview?: {
                                            /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                            rgb: [
                                                number,
                                                number,
                                                number
                                            ];
                                        };
                                    };
                                } | {
                                    /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                    ink: string;
                                } | {
                                    /** @description An older spelling of an ink reference; send `{ ink }`. */
                                    spot: {
                                        /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                        ink: string;
                                    };
                                } | {
                                    /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                                    entry: string;
                                    /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                                    palette: string;
                                };
                            };
                            /** @description What the outline and the shadow are cast from: box (the layer's box, rounded by its corners) or picture (the picture's own visible pixels, so a cut-out casts its own shape). An image with a colour mat follows its box. Absent is box. */
                            effectsFollow?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /**
                                 * @description The attribute's value, as the template stores it.
                                 * @enum {string}
                                 */
                                value: "box" | "picture";
                            };
                            /** @description How the picture fills its box: cover crops, contain shows it whole, fill stretches, tile repeats it. Absent is cover. */
                            fit: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /**
                                 * @description The attribute's value, as the template stores it.
                                 * @enum {string}
                                 */
                                value: "contain" | "cover" | "fill" | "tile";
                            };
                            /** @description The colour of the image's outline, whichever width draws it: absent is black under outlineWidthShortSide, and white, a sticker's edge, under outlineWidthShare. */
                            outlineColor?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /**
                                     * @description true lets a customer choose any colour, beside or instead of a palette.
                                     * @enum {boolean}
                                     */
                                    anyColor: true;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                                    palette: string;
                                } | {
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                                    palette?: string;
                                } | {
                                    /**
                                     * @description true lets a customer choose any colour, beside or instead of a palette.
                                     * @enum {boolean}
                                     */
                                    anyColor: true;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: {
                                    /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                    cmyk: [
                                        number,
                                        number,
                                        number,
                                        number
                                    ];
                                } | {
                                    /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                                    spot: {
                                        /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                        fallback: {
                                            /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                            cmyk: [
                                                number,
                                                number,
                                                number,
                                                number
                                            ];
                                        };
                                        /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                        name: string;
                                        /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                        preview?: {
                                            /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                            rgb: [
                                                number,
                                                number,
                                                number
                                            ];
                                        };
                                    };
                                } | {
                                    /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                    ink: string;
                                } | {
                                    /** @description An older spelling of an ink reference; send `{ ink }`. */
                                    spot: {
                                        /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                        ink: string;
                                    };
                                } | {
                                    /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                                    entry: string;
                                    /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                                    palette: string;
                                };
                            };
                            /** @description The width of an outline drawn round the picture's own pixels, like a sticker's edge, as a fraction of the picture box's shorter side (0.02 is a fiftieth of it), 0 to 0.1; absent or 0 draws no outline. Not drawn on a tiled picture. An image sets this or outlineWidthShortSide, never both. */
                            outlineWidthShare?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most value a customer may choose. */
                                    max?: number;
                                    /** @description The least value a customer may choose. */
                                    min?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The step between the values a customer may choose. */
                                    step?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: number;
                            };
                            /** @description The outline's width as a fraction of the shorter side of the layer's box (0.02 is a fiftieth of it), 0 to 0.1; absent or 0 draws no outline. On an image, traced round its box or its picture (effectsFollow); an image sets this or outlineWidthShare, never both. */
                            outlineWidthShortSide?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most value a customer may choose. */
                                    max?: number;
                                    /** @description The least value a customer may choose. */
                                    min?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The step between the values a customer may choose. */
                                    step?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: number;
                            };
                            /** @description How far the photo's colours are strengthened (up to 1) or pulled toward grey (down to -1); absent or 0 is as uploaded. A tone other than none draws no colour of the photo's own, so saturation then changes nothing. */
                            saturation?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most value a customer may choose. */
                                    max?: number;
                                    /** @description The least value a customer may choose. */
                                    min?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The step between the values a customer may choose. */
                                    step?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: number;
                            };
                            /** @description How soft the shadow is: its blur radius as a fraction of the shorter side of the layer's box, 0 (sharp) to 0.25. A shadow with no offset and no blur draws nothing. */
                            shadowBlurShortSide?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most value a customer may choose. */
                                    max?: number;
                                    /** @description The least value a customer may choose. */
                                    min?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The step between the values a customer may choose. */
                                    step?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: number;
                            };
                            /** @description The colour of the shadow drawn under the layer; absent is black. */
                            shadowColor?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /**
                                     * @description true lets a customer choose any colour, beside or instead of a palette.
                                     * @enum {boolean}
                                     */
                                    anyColor: true;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                                    palette: string;
                                } | {
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                                    palette?: string;
                                } | {
                                    /**
                                     * @description true lets a customer choose any colour, beside or instead of a palette.
                                     * @enum {boolean}
                                     */
                                    anyColor: true;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: {
                                    /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                    cmyk: [
                                        number,
                                        number,
                                        number,
                                        number
                                    ];
                                } | {
                                    /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                                    spot: {
                                        /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                        fallback: {
                                            /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                            cmyk: [
                                                number,
                                                number,
                                                number,
                                                number
                                            ];
                                        };
                                        /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                        name: string;
                                        /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                        preview?: {
                                            /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                            rgb: [
                                                number,
                                                number,
                                                number
                                            ];
                                        };
                                    };
                                } | {
                                    /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                    ink: string;
                                } | {
                                    /** @description An older spelling of an ink reference; send `{ ink }`. */
                                    spot: {
                                        /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                        ink: string;
                                    };
                                } | {
                                    /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                                    entry: string;
                                    /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                                    palette: string;
                                };
                            };
                            /** @description How far right the shadow falls, as a fraction of the shorter side of the layer's box, -0.25 to 0.25; negative is left. */
                            shadowOffsetXShortSide?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most value a customer may choose. */
                                    max?: number;
                                    /** @description The least value a customer may choose. */
                                    min?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The step between the values a customer may choose. */
                                    step?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: number;
                            };
                            /** @description How far down the shadow falls, as a fraction of the shorter side of the layer's box, -0.25 to 0.25; negative is up. */
                            shadowOffsetYShortSide?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most value a customer may choose. */
                                    max?: number;
                                    /** @description The least value a customer may choose. */
                                    min?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The step between the values a customer may choose. */
                                    step?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: number;
                            };
                            /** @description The picture's asset id; null is none chosen yet. */
                            src: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description Whether a customer may upload a picture of their own. */
                                    allowUpload?: boolean;
                                    /**
                                     * @description true cuts a customer's upload out onto a transparent background, as a new upload in its place paid from the tenant's credits; one that fails leaves their photo as it was. Absent, never.
                                     * @enum {boolean}
                                     */
                                    cutOut?: true;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description Whether a customer must change the template's default (a placeholder name or photo) before a design is accepted. Only on an offered text's content, image's picture, or shape's outline or fill. */
                                    requireChange?: boolean;
                                    /** @description Whether a customer must choose a picture. */
                                    required?: boolean;
                                    /** @description Present, an upload below `belowDpi` at the customer's chosen size is offered an upscale to `toDpi` before the proof, paid from the tenant's credits. Absent, never. */
                                    upscale?: {
                                        /** @description The print resolution, in dots per inch, below which an upload is offered an upscale. Absent, the template's minimum, else the tenant's. */
                                        belowDpi?: number;
                                        /** @description The print resolution, in dots per inch, an upload is upscaled to, and priced by: under `belowDpi`, at it or past it. Absent, `belowDpi`. */
                                        toDpi?: number;
                                    };
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: string | null;
                            };
                            /** @description The tile's size against the picture's own, when the fit is tile. */
                            tileScale?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The largest tile scale a customer may choose. */
                                    max?: number;
                                    /** @description The smallest tile scale a customer may choose. */
                                    min?: number;
                                    /** @description The step between the tile scales a customer may choose. */
                                    step?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: number;
                            };
                            /** @description What the photo's lightness is mapped onto, after brightness, contrast and saturation: none (its own colours), blackAndWhite, sepia, or duotone (from duotoneShadow in its darkest tones to duotoneHighlight in its lightest). Absent is none. */
                            tone?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /**
                                 * @description The attribute's value, as the template stores it.
                                 * @enum {string}
                                 */
                                value: "none" | "blackAndWhite" | "sepia" | "duotone";
                            };
                        };
                        /** @description The layer's rotation, scale and flip, and which of them, and its position, a customer may change. */
                        transform: {
                            /** @description Whether a customer may flip the layer. */
                            flip?: {
                                /** @description A hint shown to the customer under the control. */
                                description?: string;
                                /** @description Whether a customer may change it. */
                                editable: boolean;
                                /** @description What a customer reads the control as. */
                                label?: string;
                            };
                            /** @description Whether, and within what, a customer may resize the layer. */
                            resize?: {
                                /** @description A hint shown to the customer under the control. */
                                description?: string;
                                /** @description Whether a customer may change it. */
                                editable?: boolean;
                                /** @description What a customer reads the control as. */
                                label?: string;
                                /** @description The most height, in millimetres. */
                                maxHMm?: number;
                                /** @description The most width, in millimetres. */
                                maxWMm?: number;
                                /** @description The least height, in millimetres. */
                                minHMm?: number;
                                /** @description The least width, in millimetres. */
                                minWMm?: number;
                            };
                            /** @description Whether, and how far, a customer may rotate the layer. */
                            rotate: {
                                /** @description A hint shown to the customer under the control. */
                                description?: string;
                                /** @description Whether a customer may change it. */
                                editable: boolean;
                                /** @description What a customer reads the control as. */
                                label?: string;
                                /** @description The most rotation, in degrees. */
                                max?: number;
                                /** @description The least rotation, in degrees. */
                                min?: number;
                                /** @description The angle rotation snaps to, in degrees, e.g. 15. */
                                snapDeg?: number;
                            };
                            /** @description Whether, and how far, a customer may scale the layer. */
                            scale: {
                                /** @description A hint shown to the customer under the control. */
                                description?: string;
                                /** @description Whether a customer may change it. */
                                editable: boolean;
                                /** @description What a customer reads the control as. */
                                label?: string;
                                /** @description The most scale; 1 is as authored. */
                                max?: number;
                                /** @description The least scale; 1 is as authored. */
                                min?: number;
                                /** @description The step between the scales a customer may choose. */
                                step?: number;
                            };
                            /** @description Whether, and within what, a customer may move the layer. */
                            translate: {
                                /**
                                 * @description Where a customer's move must keep the layer: inside the safe area (the default), the print box, or anywhere.
                                 * @enum {string}
                                 */
                                bounds?: "safeArea" | "printBox" | "none";
                                /** @description A hint shown to the customer under the control. */
                                description?: string;
                                /** @description Whether a customer may change it. */
                                editable: boolean;
                                /** @description What a customer reads the control as. */
                                label?: string;
                                /** @description What a move snaps to: centre, thirds, safeEdges, layers. */
                                snapTo?: ("centre" | "thirds" | "safeEdges" | "layers")[];
                            };
                            /** @description The layer's rotation, scale and flip. */
                            value: {
                                /** @description Whether the layer is mirrored left to right, about its centre and before its rotation. */
                                flipX?: boolean;
                                /** @description Whether the layer is mirrored top to bottom, about its centre and before its rotation. */
                                flipY?: boolean;
                                /** @description Rotation about the layer's anchor, in degrees, clockwise. */
                                rotationDeg: number;
                                /** @description Scale of the layer; 1 is as authored. */
                                scale: number;
                            };
                        };
                        /** @enum {string} */
                        type: "image";
                        /**
                         * @description true lays spot varnish exactly where the layer is, on a machine that varnishes; it still prints in colour.
                         * @enum {boolean}
                         */
                        varnish?: true;
                        /** @description The layer's width as a fraction of the reference's width. Positive; uncapped, so above 1 hangs over the edge and is clipped. */
                        wFrac: number;
                    };
                    /** @description How many image layers a customer may add, 1 to 20. */
                    max: number;
                };
                /** @description Whether, and how, a customer may add shape layers. */
                shape?: {
                    /** @description The preset every added shape layer starts as: a shape layer without id, name, z, anchorTo, locked or print. What it offers is what a customer may change on the layers they add. */
                    layer: {
                        /**
                         * @description The point of the reference the layer is placed against, and the layer's own matching point: top-left puts the layer's top-left corner on the reference's.
                         * @enum {string}
                         */
                        anchor: "top-left" | "top-center" | "top-right" | "center-left" | "center" | "center-right" | "bottom-left" | "bottom-center" | "bottom-right";
                        /**
                         * @description How it mixes with the layers under it, per ink. Absent is normal.
                         * @enum {string}
                         */
                        blend?: "multiply" | "screen" | "overlay" | "darken" | "lighten";
                        /** @description The layer's height as a fraction of the reference's height. Positive; uncapped, so above 1 hangs over the edge and is clipped. */
                        hFrac: number;
                        /** @description How far the layer sits from its anchor, as fractions of the reference, always toward the reference's centre: { x: 0.05, y: 0.05 } nudges it 5 % in from any corner. Ignored on a centred axis. */
                        offsetFrac: {
                            /** @description Across, as a fraction of the reference's width: 0.05 is 5 %. Toward the centre; negative pushes outward. Uncapped. */
                            x: number;
                            /** @description Down or up, as a fraction of the reference's height: 0.05 is 5 %. Toward the centre; negative pushes outward. Uncapped. */
                            y: number;
                        };
                        /** @description The layer's opacity, which a customer may be offered. Absent is full and not offered. */
                        opacity?: {
                            /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                            constraints?: {
                                /** @description The most opacity a customer may choose, 0.01 to 1. */
                                max?: number;
                                /** @description The least opacity a customer may choose, 0.01 to 1. */
                                min?: number;
                                /** @description The step between choosable opacities, e.g. 0.05. */
                                step?: number;
                            };
                            /** @description A hint shown to the customer under the attribute's field. */
                            description?: string;
                            /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                            editable: boolean;
                            /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                            fieldKey?: string;
                            /** @description What a customer reads the attribute as, when editable. */
                            label?: string;
                            /** @description How opaque the whole layer is: 1 is full, 0.01 the least. */
                            value: number;
                        };
                        props: {
                            /** @description Where the picture sits in its frame, under cover. Absent is uncropped. */
                            crop?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most zoom a customer may choose; absent is 3. */
                                    maxZoom?: number;
                                    /** @description The least zoom a customer may choose; absent is 1. */
                                    minZoom?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: {
                                    /** @description How far the picture's centre sits right of the frame's centre, in frame widths: 0.1 is a tenth of the frame. Clamped so the picture always covers the frame, never refused. */
                                    xFrac: number;
                                    /** @description How far the picture's centre sits below the frame's centre, in frame heights: 0.1 is a tenth of the frame. Clamped so the picture always covers the frame, never refused. */
                                    yFrac: number;
                                    /** @description The picture's scale over what cover gives it: 1 is the picture just covering the frame, up to 5. */
                                    zoom: number;
                                };
                            };
                            /** @description What the silhouette is painted with: a colour, a gradient across its box, or a picture clipped to it. */
                            fill: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description Whether a customer may upload a picture of their own. */
                                    allowUpload?: boolean;
                                    /**
                                     * @description true lets a customer choose any colour, beside or instead of a palette.
                                     * @enum {boolean}
                                     */
                                    anyColor?: true;
                                    /**
                                     * @description true cuts a customer's upload out onto a transparent background, as a new upload in its place paid from the tenant's credits; one that fails leaves their photo as it was. Absent, never.
                                     * @enum {boolean}
                                     */
                                    cutOut?: true;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                                    palette?: string;
                                    /** @description Whether a customer must change the template's default (a placeholder name or photo) before a design is accepted. Only on an offered text's content, image's picture, or shape's outline or fill. */
                                    requireChange?: boolean;
                                    /** @description Whether a customer must choose a picture. */
                                    required?: boolean;
                                    /** @description Present, an upload below `belowDpi` at the customer's chosen size is offered an upscale to `toDpi` before the proof, paid from the tenant's credits. Absent, never. */
                                    upscale?: {
                                        /** @description The print resolution, in dots per inch, below which an upload is offered an upscale. Absent, the template's minimum, else the tenant's. */
                                        belowDpi?: number;
                                        /** @description The print resolution, in dots per inch, an upload is upscaled to, and priced by: under `belowDpi`, at it or past it. Absent, `belowDpi`. */
                                        toDpi?: number;
                                    };
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: {
                                    /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                    cmyk: [
                                        number,
                                        number,
                                        number,
                                        number
                                    ];
                                } | {
                                    /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                                    spot: {
                                        /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                        fallback: {
                                            /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                            cmyk: [
                                                number,
                                                number,
                                                number,
                                                number
                                            ];
                                        };
                                        /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                        name: string;
                                        /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                        preview?: {
                                            /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                            rgb: [
                                                number,
                                                number,
                                                number
                                            ];
                                        };
                                    };
                                } | {
                                    /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                    ink: string;
                                } | {
                                    /** @description An older spelling of an ink reference; send `{ ink }`. */
                                    spot: {
                                        /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                        ink: string;
                                    };
                                } | {
                                    /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                                    entry: string;
                                    /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                                    palette: string;
                                } | {
                                    /** @description linear crosses a shape's box or text's letters at an angle; radial from the centre to the farthest corner. */
                                    gradient: {
                                        /** @description The direction the colours run, in degrees clockwise from straight up: 90 runs left to right, 180 top to bottom. It spans a shape's box or a text's letters. */
                                        angleDeg: number;
                                        /** @enum {string} */
                                        kind: "linear";
                                        /** @description The gradient's colours, 2 to 8, in order of position. Blended in CMYK, as the print blends them. */
                                        stops: {
                                            /** @description Where the colour sits along the gradient: 0 is its start, 1 its end. Stops are in order; two at one position make a hard edge. */
                                            at: number;
                                            /** @description The colour at this stop: a CMYK colour, one of your inks, or a palette entry. A spot ink cannot be one: a gradient blends process colours. */
                                            color: {
                                                /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                                cmyk: [
                                                    number,
                                                    number,
                                                    number,
                                                    number
                                                ];
                                            } | {
                                                /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                                                spot: {
                                                    /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                                    fallback: {
                                                        /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                                        cmyk: [
                                                            number,
                                                            number,
                                                            number,
                                                            number
                                                        ];
                                                    };
                                                    /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                                    name: string;
                                                    /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                                    preview?: {
                                                        /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                                        rgb: [
                                                            number,
                                                            number,
                                                            number
                                                        ];
                                                    };
                                                };
                                            } | {
                                                /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                                ink: string;
                                            } | {
                                                /** @description An older spelling of an ink reference; send `{ ink }`. */
                                                spot: {
                                                    /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                                    ink: string;
                                                };
                                            } | {
                                                /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                                                entry: string;
                                                /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                                                palette: string;
                                            };
                                        }[];
                                    } | {
                                        /** @enum {string} */
                                        kind: "radial";
                                        /** @description The gradient's colours, 2 to 8, in order of position. Blended in CMYK, as the print blends them. */
                                        stops: {
                                            /** @description Where the colour sits along the gradient: 0 is its start, 1 its end. Stops are in order; two at one position make a hard edge. */
                                            at: number;
                                            /** @description The colour at this stop: a CMYK colour, one of your inks, or a palette entry. A spot ink cannot be one: a gradient blends process colours. */
                                            color: {
                                                /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                                cmyk: [
                                                    number,
                                                    number,
                                                    number,
                                                    number
                                                ];
                                            } | {
                                                /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                                                spot: {
                                                    /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                                    fallback: {
                                                        /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                                        cmyk: [
                                                            number,
                                                            number,
                                                            number,
                                                            number
                                                        ];
                                                    };
                                                    /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                                    name: string;
                                                    /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                                    preview?: {
                                                        /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                                        rgb: [
                                                            number,
                                                            number,
                                                            number
                                                        ];
                                                    };
                                                };
                                            } | {
                                                /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                                ink: string;
                                            } | {
                                                /** @description An older spelling of an ink reference; send `{ ink }`. */
                                                spot: {
                                                    /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                                    ink: string;
                                                };
                                            } | {
                                                /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                                                entry: string;
                                                /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                                                palette: string;
                                            };
                                        }[];
                                    };
                                } | {
                                    /** @description A picture's asset id, clipped to the shape; empty while none is chosen. */
                                    imageAssetId: string;
                                };
                            };
                            /** @description How the picture fills its box: cover crops, contain shows it whole, fill stretches, tile repeats it. Absent is cover. */
                            fit?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /**
                                 * @description The attribute's value, as the template stores it.
                                 * @enum {string}
                                 */
                                value: "contain" | "cover" | "fill" | "tile";
                            };
                            /** @description The colour of the line drawn around the layer's edge, outside it; absent is black. */
                            outlineColor?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /**
                                     * @description true lets a customer choose any colour, beside or instead of a palette.
                                     * @enum {boolean}
                                     */
                                    anyColor: true;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                                    palette: string;
                                } | {
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                                    palette?: string;
                                } | {
                                    /**
                                     * @description true lets a customer choose any colour, beside or instead of a palette.
                                     * @enum {boolean}
                                     */
                                    anyColor: true;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: {
                                    /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                    cmyk: [
                                        number,
                                        number,
                                        number,
                                        number
                                    ];
                                } | {
                                    /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                                    spot: {
                                        /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                        fallback: {
                                            /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                            cmyk: [
                                                number,
                                                number,
                                                number,
                                                number
                                            ];
                                        };
                                        /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                        name: string;
                                        /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                        preview?: {
                                            /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                            rgb: [
                                                number,
                                                number,
                                                number
                                            ];
                                        };
                                    };
                                } | {
                                    /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                    ink: string;
                                } | {
                                    /** @description An older spelling of an ink reference; send `{ ink }`. */
                                    spot: {
                                        /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                        ink: string;
                                    };
                                } | {
                                    /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                                    entry: string;
                                    /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                                    palette: string;
                                };
                            };
                            /** @description The outline's width as a fraction of the shorter side of the layer's box (0.02 is a fiftieth of it), 0 to 0.1; absent or 0 draws no outline. On an image, traced round its box or its picture (effectsFollow); an image sets this or outlineWidthShare, never both. */
                            outlineWidthShortSide?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most value a customer may choose. */
                                    max?: number;
                                    /** @description The least value a customer may choose. */
                                    min?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The step between the values a customer may choose. */
                                    step?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: number;
                            };
                            /** @description How soft the shadow is: its blur radius as a fraction of the shorter side of the layer's box, 0 (sharp) to 0.25. A shadow with no offset and no blur draws nothing. */
                            shadowBlurShortSide?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most value a customer may choose. */
                                    max?: number;
                                    /** @description The least value a customer may choose. */
                                    min?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The step between the values a customer may choose. */
                                    step?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: number;
                            };
                            /** @description The colour of the shadow drawn under the layer; absent is black. */
                            shadowColor?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /**
                                     * @description true lets a customer choose any colour, beside or instead of a palette.
                                     * @enum {boolean}
                                     */
                                    anyColor: true;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                                    palette: string;
                                } | {
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                                    palette?: string;
                                } | {
                                    /**
                                     * @description true lets a customer choose any colour, beside or instead of a palette.
                                     * @enum {boolean}
                                     */
                                    anyColor: true;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: {
                                    /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                    cmyk: [
                                        number,
                                        number,
                                        number,
                                        number
                                    ];
                                } | {
                                    /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                                    spot: {
                                        /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                        fallback: {
                                            /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                            cmyk: [
                                                number,
                                                number,
                                                number,
                                                number
                                            ];
                                        };
                                        /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                        name: string;
                                        /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                        preview?: {
                                            /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                            rgb: [
                                                number,
                                                number,
                                                number
                                            ];
                                        };
                                    };
                                } | {
                                    /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                    ink: string;
                                } | {
                                    /** @description An older spelling of an ink reference; send `{ ink }`. */
                                    spot: {
                                        /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                        ink: string;
                                    };
                                } | {
                                    /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                                    entry: string;
                                    /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                                    palette: string;
                                };
                            };
                            /** @description How far right the shadow falls, as a fraction of the shorter side of the layer's box, -0.25 to 0.25; negative is left. */
                            shadowOffsetXShortSide?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most value a customer may choose. */
                                    max?: number;
                                    /** @description The least value a customer may choose. */
                                    min?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The step between the values a customer may choose. */
                                    step?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: number;
                            };
                            /** @description How far down the shadow falls, as a fraction of the shorter side of the layer's box, -0.25 to 0.25; negative is up. */
                            shadowOffsetYShortSide?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most value a customer may choose. */
                                    max?: number;
                                    /** @description The least value a customer may choose. */
                                    min?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The step between the values a customer may choose. */
                                    step?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: number;
                            };
                            /** @description The layer's silhouette: inline geometry or one of the tenant's shapes. */
                            shape: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /**
                                     * @description true lets a customer choose no shape at all.
                                     * @enum {boolean}
                                     */
                                    allowEmpty?: true;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description Whether a customer must change the template's default (a placeholder name or photo) before a design is accepted. Only on an offered text's content, image's picture, or shape's outline or fill. */
                                    requireChange?: boolean;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: {
                                    /** @description SVG path data in fractions of its box, (0,0) its top-left and (1,1) its bottom-right: `M 0 0 L 1 0 L 1 1 L 0 1 Z` is the whole box. No arcs. */
                                    dFrac: string;
                                    /**
                                     * @description Inline path geometry.
                                     * @enum {string}
                                     */
                                    type: "path";
                                } | {
                                    /** @description The shape's id, `shp_…`, as list_shapes returns it. */
                                    shapeId: string;
                                    /**
                                     * @description One of the tenant's shapes, by id.
                                     * @enum {string}
                                     */
                                    type: "shape";
                                };
                            };
                            /** @description The tile's size against the picture's own, when the fit is tile. */
                            tileScale?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The largest tile scale a customer may choose. */
                                    max?: number;
                                    /** @description The smallest tile scale a customer may choose. */
                                    min?: number;
                                    /** @description The step between the tile scales a customer may choose. */
                                    step?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: number;
                            };
                        };
                        /** @description The layer's rotation, scale and flip, and which of them, and its position, a customer may change. */
                        transform: {
                            /** @description Whether a customer may flip the layer. */
                            flip?: {
                                /** @description A hint shown to the customer under the control. */
                                description?: string;
                                /** @description Whether a customer may change it. */
                                editable: boolean;
                                /** @description What a customer reads the control as. */
                                label?: string;
                            };
                            /** @description Whether, and within what, a customer may resize the layer. */
                            resize?: {
                                /** @description A hint shown to the customer under the control. */
                                description?: string;
                                /** @description Whether a customer may change it. */
                                editable?: boolean;
                                /** @description What a customer reads the control as. */
                                label?: string;
                                /** @description The most height, in millimetres. */
                                maxHMm?: number;
                                /** @description The most width, in millimetres. */
                                maxWMm?: number;
                                /** @description The least height, in millimetres. */
                                minHMm?: number;
                                /** @description The least width, in millimetres. */
                                minWMm?: number;
                            };
                            /** @description Whether, and how far, a customer may rotate the layer. */
                            rotate: {
                                /** @description A hint shown to the customer under the control. */
                                description?: string;
                                /** @description Whether a customer may change it. */
                                editable: boolean;
                                /** @description What a customer reads the control as. */
                                label?: string;
                                /** @description The most rotation, in degrees. */
                                max?: number;
                                /** @description The least rotation, in degrees. */
                                min?: number;
                                /** @description The angle rotation snaps to, in degrees, e.g. 15. */
                                snapDeg?: number;
                            };
                            /** @description Whether, and how far, a customer may scale the layer. */
                            scale: {
                                /** @description A hint shown to the customer under the control. */
                                description?: string;
                                /** @description Whether a customer may change it. */
                                editable: boolean;
                                /** @description What a customer reads the control as. */
                                label?: string;
                                /** @description The most scale; 1 is as authored. */
                                max?: number;
                                /** @description The least scale; 1 is as authored. */
                                min?: number;
                                /** @description The step between the scales a customer may choose. */
                                step?: number;
                            };
                            /** @description Whether, and within what, a customer may move the layer. */
                            translate: {
                                /**
                                 * @description Where a customer's move must keep the layer: inside the safe area (the default), the print box, or anywhere.
                                 * @enum {string}
                                 */
                                bounds?: "safeArea" | "printBox" | "none";
                                /** @description A hint shown to the customer under the control. */
                                description?: string;
                                /** @description Whether a customer may change it. */
                                editable: boolean;
                                /** @description What a customer reads the control as. */
                                label?: string;
                                /** @description What a move snaps to: centre, thirds, safeEdges, layers. */
                                snapTo?: ("centre" | "thirds" | "safeEdges" | "layers")[];
                            };
                            /** @description The layer's rotation, scale and flip. */
                            value: {
                                /** @description Whether the layer is mirrored left to right, about its centre and before its rotation. */
                                flipX?: boolean;
                                /** @description Whether the layer is mirrored top to bottom, about its centre and before its rotation. */
                                flipY?: boolean;
                                /** @description Rotation about the layer's anchor, in degrees, clockwise. */
                                rotationDeg: number;
                                /** @description Scale of the layer; 1 is as authored. */
                                scale: number;
                            };
                        };
                        /** @enum {string} */
                        type: "shape";
                        /**
                         * @description true lays spot varnish exactly where the layer is, on a machine that varnishes; it still prints in colour.
                         * @enum {boolean}
                         */
                        varnish?: true;
                        /** @description The layer's width as a fraction of the reference's width. Positive; uncapped, so above 1 hangs over the edge and is clipped. */
                        wFrac: number;
                    };
                    /** @description How many shape layers a customer may add, 1 to 20. */
                    max: number;
                };
                /** @description Whether, and how, a customer may add text layers. */
                text?: {
                    /** @description The preset every added text layer starts as: a text layer without id, name, z, anchorTo, locked or print. What it offers is what a customer may change on the layers they add. */
                    layer: {
                        /**
                         * @description The point of the reference the layer is placed against, and the layer's own matching point: top-left puts the layer's top-left corner on the reference's.
                         * @enum {string}
                         */
                        anchor: "top-left" | "top-center" | "top-right" | "center-left" | "center" | "center-right" | "bottom-left" | "bottom-center" | "bottom-right";
                        /**
                         * @description How it mixes with the layers under it, per ink. Absent is normal.
                         * @enum {string}
                         */
                        blend?: "multiply" | "screen" | "overlay" | "darken" | "lighten";
                        /** @description The layer's height as a fraction of the reference's height. Positive; uncapped, so above 1 hangs over the edge and is clipped. */
                        hFrac: number;
                        /** @description A backdrop painted behind this layer's content at exactly its box: a colour, or a filled shape. Text and image layers only. */
                        mat?: {
                            /** @description The backdrop's colour. */
                            color: {
                                /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                cmyk: [
                                    number,
                                    number,
                                    number,
                                    number
                                ];
                            } | {
                                /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                                spot: {
                                    /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                    fallback: {
                                        /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                        cmyk: [
                                            number,
                                            number,
                                            number,
                                            number
                                        ];
                                    };
                                    /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                    name: string;
                                    /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                    preview?: {
                                        /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                        rgb: [
                                            number,
                                            number,
                                            number
                                        ];
                                    };
                                };
                            } | {
                                /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                ink: string;
                            } | {
                                /** @description An older spelling of an ink reference; send `{ ink }`. */
                                spot: {
                                    /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                    ink: string;
                                };
                            } | {
                                /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                                entry: string;
                                /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                                palette: string;
                            };
                            /**
                             * @description color is a plain backdrop; shape fills a silhouette.
                             * @enum {string}
                             */
                            kind: "color";
                        } | {
                            /** @description The silhouette's colour. */
                            fill: {
                                /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                cmyk: [
                                    number,
                                    number,
                                    number,
                                    number
                                ];
                            } | {
                                /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                                spot: {
                                    /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                    fallback: {
                                        /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                        cmyk: [
                                            number,
                                            number,
                                            number,
                                            number
                                        ];
                                    };
                                    /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                    name: string;
                                    /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                    preview?: {
                                        /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                        rgb: [
                                            number,
                                            number,
                                            number
                                        ];
                                    };
                                };
                            } | {
                                /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                ink: string;
                            } | {
                                /** @description An older spelling of an ink reference; send `{ ink }`. */
                                spot: {
                                    /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                    ink: string;
                                };
                            } | {
                                /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                                entry: string;
                                /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                                palette: string;
                            };
                            /**
                             * @description color is a plain backdrop; shape fills a silhouette.
                             * @enum {string}
                             */
                            kind: "shape";
                            /** @description The backdrop's silhouette, at the layer's box. */
                            shape: {
                                /** @description SVG path data in fractions of its box, (0,0) its top-left and (1,1) its bottom-right: `M 0 0 L 1 0 L 1 1 L 0 1 Z` is the whole box. No arcs. */
                                dFrac: string;
                                /**
                                 * @description Inline path geometry.
                                 * @enum {string}
                                 */
                                type: "path";
                            } | {
                                /** @description The shape's id, `shp_…`, as list_shapes returns it. */
                                shapeId: string;
                                /**
                                 * @description One of the tenant's shapes, by id.
                                 * @enum {string}
                                 */
                                type: "shape";
                            };
                        };
                        /** @description How far the layer sits from its anchor, as fractions of the reference, always toward the reference's centre: { x: 0.05, y: 0.05 } nudges it 5 % in from any corner. Ignored on a centred axis. */
                        offsetFrac: {
                            /** @description Across, as a fraction of the reference's width: 0.05 is 5 %. Toward the centre; negative pushes outward. Uncapped. */
                            x: number;
                            /** @description Down or up, as a fraction of the reference's height: 0.05 is 5 %. Toward the centre; negative pushes outward. Uncapped. */
                            y: number;
                        };
                        /** @description The layer's opacity, which a customer may be offered. Absent is full and not offered. */
                        opacity?: {
                            /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                            constraints?: {
                                /** @description The most opacity a customer may choose, 0.01 to 1. */
                                max?: number;
                                /** @description The least opacity a customer may choose, 0.01 to 1. */
                                min?: number;
                                /** @description The step between choosable opacities, e.g. 0.05. */
                                step?: number;
                            };
                            /** @description A hint shown to the customer under the attribute's field. */
                            description?: string;
                            /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                            editable: boolean;
                            /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                            fieldKey?: string;
                            /** @description What a customer reads the attribute as, when editable. */
                            label?: string;
                            /** @description How opaque the whole layer is: 1 is full, 0.01 the least. */
                            value: number;
                        };
                        props: {
                            /** @description Horizontal alignment in the text box. */
                            align: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most characters a customer may type. */
                                    maxLength?: number;
                                    /** @description The most lines a customer's text may take. */
                                    maxLines?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description Whether a customer must change the template's default (a placeholder name or photo) before a design is accepted. Only on an offered text's content, image's picture, or shape's outline or fill. */
                                    requireChange?: boolean;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /**
                                 * @description The attribute's value, as the template stores it.
                                 * @enum {string}
                                 */
                                value: "left" | "center" | "right";
                            };
                            /** @description The text. */
                            content: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most characters a customer may type. */
                                    maxLength?: number;
                                    /** @description The most lines a customer's text may take. */
                                    maxLines?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description Whether a customer must change the template's default (a placeholder name or photo) before a design is accepted. Only on an offered text's content, image's picture, or shape's outline or fill. */
                                    requireChange?: boolean;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: string;
                            };
                            /** @description The colour of the text, or a gradient across it. */
                            fill: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /**
                                     * @description true lets a customer choose any colour, beside or instead of a palette.
                                     * @enum {boolean}
                                     */
                                    anyColor: true;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                                    palette: string;
                                } | {
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                                    palette?: string;
                                } | {
                                    /**
                                     * @description true lets a customer choose any colour, beside or instead of a palette.
                                     * @enum {boolean}
                                     */
                                    anyColor: true;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: {
                                    /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                    cmyk: [
                                        number,
                                        number,
                                        number,
                                        number
                                    ];
                                } | {
                                    /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                                    spot: {
                                        /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                        fallback: {
                                            /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                            cmyk: [
                                                number,
                                                number,
                                                number,
                                                number
                                            ];
                                        };
                                        /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                        name: string;
                                        /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                        preview?: {
                                            /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                            rgb: [
                                                number,
                                                number,
                                                number
                                            ];
                                        };
                                    };
                                } | {
                                    /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                    ink: string;
                                } | {
                                    /** @description An older spelling of an ink reference; send `{ ink }`. */
                                    spot: {
                                        /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                        ink: string;
                                    };
                                } | {
                                    /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                                    entry: string;
                                    /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                                    palette: string;
                                } | {
                                    /** @description linear crosses a shape's box or text's letters at an angle; radial from the centre to the farthest corner. */
                                    gradient: {
                                        /** @description The direction the colours run, in degrees clockwise from straight up: 90 runs left to right, 180 top to bottom. It spans a shape's box or a text's letters. */
                                        angleDeg: number;
                                        /** @enum {string} */
                                        kind: "linear";
                                        /** @description The gradient's colours, 2 to 8, in order of position. Blended in CMYK, as the print blends them. */
                                        stops: {
                                            /** @description Where the colour sits along the gradient: 0 is its start, 1 its end. Stops are in order; two at one position make a hard edge. */
                                            at: number;
                                            /** @description The colour at this stop: a CMYK colour, one of your inks, or a palette entry. A spot ink cannot be one: a gradient blends process colours. */
                                            color: {
                                                /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                                cmyk: [
                                                    number,
                                                    number,
                                                    number,
                                                    number
                                                ];
                                            } | {
                                                /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                                                spot: {
                                                    /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                                    fallback: {
                                                        /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                                        cmyk: [
                                                            number,
                                                            number,
                                                            number,
                                                            number
                                                        ];
                                                    };
                                                    /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                                    name: string;
                                                    /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                                    preview?: {
                                                        /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                                        rgb: [
                                                            number,
                                                            number,
                                                            number
                                                        ];
                                                    };
                                                };
                                            } | {
                                                /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                                ink: string;
                                            } | {
                                                /** @description An older spelling of an ink reference; send `{ ink }`. */
                                                spot: {
                                                    /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                                    ink: string;
                                                };
                                            } | {
                                                /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                                                entry: string;
                                                /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                                                palette: string;
                                            };
                                        }[];
                                    } | {
                                        /** @enum {string} */
                                        kind: "radial";
                                        /** @description The gradient's colours, 2 to 8, in order of position. Blended in CMYK, as the print blends them. */
                                        stops: {
                                            /** @description Where the colour sits along the gradient: 0 is its start, 1 its end. Stops are in order; two at one position make a hard edge. */
                                            at: number;
                                            /** @description The colour at this stop: a CMYK colour, one of your inks, or a palette entry. A spot ink cannot be one: a gradient blends process colours. */
                                            color: {
                                                /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                                cmyk: [
                                                    number,
                                                    number,
                                                    number,
                                                    number
                                                ];
                                            } | {
                                                /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                                                spot: {
                                                    /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                                    fallback: {
                                                        /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                                        cmyk: [
                                                            number,
                                                            number,
                                                            number,
                                                            number
                                                        ];
                                                    };
                                                    /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                                    name: string;
                                                    /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                                    preview?: {
                                                        /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                                        rgb: [
                                                            number,
                                                            number,
                                                            number
                                                        ];
                                                    };
                                                };
                                            } | {
                                                /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                                ink: string;
                                            } | {
                                                /** @description An older spelling of an ink reference; send `{ ink }`. */
                                                spot: {
                                                    /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                                    ink: string;
                                                };
                                            } | {
                                                /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                                                entry: string;
                                                /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                                                palette: string;
                                            };
                                        }[];
                                    };
                                };
                            };
                            /** @description The font family, one of those the tenant offers. */
                            fontFamily: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most characters a customer may type. */
                                    maxLength?: number;
                                    /** @description The most lines a customer's text may take. */
                                    maxLines?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description Whether a customer must change the template's default (a placeholder name or photo) before a design is accepted. Only on an offered text's content, image's picture, or shape's outline or fill. */
                                    requireChange?: boolean;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: string;
                            };
                            /** @description The font size as a fraction of the plate's HEIGHT, as is its offered range: 0.05 is 5 % of the height. Positive. */
                            fontSizeFrac: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most value a customer may choose. */
                                    max?: number;
                                    /** @description The least value a customer may choose. */
                                    min?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The step between the values a customer may choose. */
                                    step?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: number;
                            };
                            /** @description Upright (normal) or italic; absent is normal. An italic text draws its font's italic faces, or its upright ones when the font has none. Set by the author: a customer is not offered it. */
                            fontStyle?: {
                                /**
                                 * @description Always false: the author sets it, a customer may not.
                                 * @enum {boolean}
                                 */
                                editable: false;
                                /**
                                 * @description The attribute's value, as the template stores it.
                                 * @enum {string}
                                 */
                                value: "normal" | "italic";
                            };
                            /** @description The font weight, 1 to 1000; 400 is regular, 700 bold. */
                            fontWeight?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most value a customer may choose. */
                                    max?: number;
                                    /** @description The least value a customer may choose. */
                                    min?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The step between the values a customer may choose. */
                                    step?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: number;
                            };
                            /** @description The space added after each letter, as a fraction of the drawn text size (0.1 is a tenth of it), -0.1 to 1; absent or 0 is the font's own spacing. */
                            letterSpacingEm?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most value a customer may choose. */
                                    max?: number;
                                    /** @description The least value a customer may choose. */
                                    min?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The step between the values a customer may choose. */
                                    step?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: number;
                            };
                            /** @description The line spacing as a multiple of the font's own, 0.5 to 3; absent or 1 is the font's own. */
                            lineHeight?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most value a customer may choose. */
                                    max?: number;
                                    /** @description The least value a customer may choose. */
                                    min?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The step between the values a customer may choose. */
                                    step?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: number;
                            };
                            /** @description The colour of the line drawn around every letter, outside its fill; absent is black. */
                            outlineColor?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /**
                                     * @description true lets a customer choose any colour, beside or instead of a palette.
                                     * @enum {boolean}
                                     */
                                    anyColor: true;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                                    palette: string;
                                } | {
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                                    palette?: string;
                                } | {
                                    /**
                                     * @description true lets a customer choose any colour, beside or instead of a palette.
                                     * @enum {boolean}
                                     */
                                    anyColor: true;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: {
                                    /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                    cmyk: [
                                        number,
                                        number,
                                        number,
                                        number
                                    ];
                                } | {
                                    /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                                    spot: {
                                        /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                        fallback: {
                                            /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                            cmyk: [
                                                number,
                                                number,
                                                number,
                                                number
                                            ];
                                        };
                                        /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                        name: string;
                                        /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                        preview?: {
                                            /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                            rgb: [
                                                number,
                                                number,
                                                number
                                            ];
                                        };
                                    };
                                } | {
                                    /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                    ink: string;
                                } | {
                                    /** @description An older spelling of an ink reference; send `{ ink }`. */
                                    spot: {
                                        /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                        ink: string;
                                    };
                                } | {
                                    /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                                    entry: string;
                                    /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                                    palette: string;
                                };
                            };
                            /** @description The outline's width as a fraction of the drawn text size (0.05 is a twentieth of it), 0 to 0.25; absent or 0 draws no outline. */
                            outlineWidthEm?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most value a customer may choose. */
                                    max?: number;
                                    /** @description The least value a customer may choose. */
                                    min?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The step between the values a customer may choose. */
                                    step?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: number;
                            };
                            /** @description How soft the shadow is: its blur radius as a fraction of the drawn text size, 0 (sharp) to 1. A shadow with no offset and no blur draws nothing. */
                            shadowBlurEm?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most value a customer may choose. */
                                    max?: number;
                                    /** @description The least value a customer may choose. */
                                    min?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The step between the values a customer may choose. */
                                    step?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: number;
                            };
                            /** @description The colour of the shadow drawn under the text; absent is black. */
                            shadowColor?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /**
                                     * @description true lets a customer choose any colour, beside or instead of a palette.
                                     * @enum {boolean}
                                     */
                                    anyColor: true;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                                    palette: string;
                                } | {
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                                    palette?: string;
                                } | {
                                    /**
                                     * @description true lets a customer choose any colour, beside or instead of a palette.
                                     * @enum {boolean}
                                     */
                                    anyColor: true;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: {
                                    /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                    cmyk: [
                                        number,
                                        number,
                                        number,
                                        number
                                    ];
                                } | {
                                    /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                                    spot: {
                                        /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                        fallback: {
                                            /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                            cmyk: [
                                                number,
                                                number,
                                                number,
                                                number
                                            ];
                                        };
                                        /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                        name: string;
                                        /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                        preview?: {
                                            /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                            rgb: [
                                                number,
                                                number,
                                                number
                                            ];
                                        };
                                    };
                                } | {
                                    /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                    ink: string;
                                } | {
                                    /** @description An older spelling of an ink reference; send `{ ink }`. */
                                    spot: {
                                        /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                        ink: string;
                                    };
                                } | {
                                    /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                                    entry: string;
                                    /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                                    palette: string;
                                };
                            };
                            /** @description How far right the shadow falls, as a fraction of the drawn text size, -1 to 1; negative is left. */
                            shadowOffsetXEm?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most value a customer may choose. */
                                    max?: number;
                                    /** @description The least value a customer may choose. */
                                    min?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The step between the values a customer may choose. */
                                    step?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: number;
                            };
                            /** @description How far down the shadow falls, as a fraction of the drawn text size, -1 to 1; negative is up. */
                            shadowOffsetYEm?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most value a customer may choose. */
                                    max?: number;
                                    /** @description The least value a customer may choose. */
                                    min?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description The step between the values a customer may choose. */
                                    step?: number;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /** @description The attribute's value, as the template stores it. */
                                value: number;
                            };
                            /** @description How the letters are cased when drawn: asTyped, upper, lower or title (each word's first letter a capital). The text itself is kept as typed. Absent is asTyped. */
                            textCase?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most characters a customer may type. */
                                    maxLength?: number;
                                    /** @description The most lines a customer's text may take. */
                                    maxLines?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description Whether a customer must change the template's default (a placeholder name or photo) before a design is accepted. Only on an offered text's content, image's picture, or shape's outline or fill. */
                                    requireChange?: boolean;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /**
                                 * @description The attribute's value, as the template stores it.
                                 * @enum {string}
                                 */
                                value: "asTyped" | "upper" | "lower" | "title";
                            };
                            /** @description Vertical alignment in the text box; absent is middle. */
                            valign?: {
                                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                                constraints?: {
                                    /** @description The most characters a customer may type. */
                                    maxLength?: number;
                                    /** @description The most lines a customer's text may take. */
                                    maxLines?: number;
                                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                                    oneOf?: string[];
                                    /** @description Whether a customer must change the template's default (a placeholder name or photo) before a design is accepted. Only on an offered text's content, image's picture, or shape's outline or fill. */
                                    requireChange?: boolean;
                                };
                                /** @description A hint shown to the customer under the attribute's field. */
                                description?: string;
                                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                                editable: boolean;
                                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                                fieldKey?: string;
                                /** @description What a customer reads the attribute as, when editable. */
                                label?: string;
                                /**
                                 * @description The attribute's value, as the template stores it.
                                 * @enum {string}
                                 */
                                value: "top" | "middle" | "bottom";
                            };
                        };
                        /** @description What the text layer does when its text does not fit its box. Every size here is a fraction of the plate. */
                        textBox: {
                            /**
                             * @description true breaks a word wider than the box across lines rather than refusing it.
                             * @enum {boolean}
                             */
                            breakWords?: true;
                            /**
                             * @description adapt keeps the font size and grows the box, then shrinks the text, as far as the limits below allow.
                             * @enum {string}
                             */
                            mode: "adapt";
                            /**
                             * @description Which way the box grows first. Absent is widerFirst.
                             * @enum {string}
                             */
                            order?: "widerFirst" | "tallerFirst";
                            /** @description The smallest font size the text may shrink to, as a fraction of the plate's height. Absent, it does not shrink. */
                            shrinkTo?: number;
                            /** @description How tall the box may grow, as a fraction of the plate's height, at most 1. Absent, it does not grow taller. */
                            tallerTo?: number;
                            /**
                             * @description What happens to text that still does not fit: clamp cuts it at the box, reject refuses the text.
                             * @enum {string}
                             */
                            then: "clamp" | "reject";
                            /** @description How wide the box may grow, as a fraction of the plate's width, at most 1. Absent, it does not widen. */
                            widenTo?: number;
                        } | {
                            /**
                             * @description true breaks a word wider than the box across lines rather than refusing it.
                             * @enum {boolean}
                             */
                            breakWords?: true;
                            /** @description The largest font size, as a fraction of the plate's height; null is no limit, as large as one line of the box. */
                            max: number | null;
                            /** @description The smallest font size, as a fraction of the plate's height. */
                            min: number;
                            /**
                             * @description fill sizes the text to fill the box, between min and max.
                             * @enum {string}
                             */
                            mode: "fill";
                            /**
                             * @description What happens to text that still does not fit: clamp cuts it at the box, reject refuses the text.
                             * @enum {string}
                             */
                            then: "clamp" | "reject";
                        };
                        /** @description A curve the text runs along, as one line: absent is straight lines. The text box still fits it along the curve's length: it shrinks, then is cut or refused, never widening or growing taller. */
                        textPath?: {
                            /** @description Where the text's run is centred, in degrees clockwise from 12 o'clock: 0 is the top, 90 the right, 180 the bottom. */
                            centerDeg: number;
                            /**
                             * @description Which side of the curve the letters stand on: outside reads clockwise round it (the top of a badge); inside hangs inside it and runs the other way, so text at the bottom reads left to right.
                             * @enum {string}
                             */
                            side: "outside" | "inside";
                            /** @description How much of the oval the arc covers, in degrees, above 0 and at most 360: 360 is a whole circle. */
                            sweepDeg: number;
                            /**
                             * @description Along the oval inside the layer's box, a circle when the box is square: the box is the radius.
                             * @enum {string}
                             */
                            type: "arc";
                        } | {
                            /** @description Where the text's run is centred, in degrees clockwise from 12 o'clock: 0 is the top, 90 the right, 180 the bottom. */
                            centerDeg: number;
                            shape: {
                                /** @description SVG path data in fractions of its box, (0,0) its top-left and (1,1) its bottom-right: `M 0 0 L 1 0 L 1 1 L 0 1 Z` is the whole box. No arcs. */
                                dFrac: string;
                                /**
                                 * @description Inline path geometry.
                                 * @enum {string}
                                 */
                                type: "path";
                            } | {
                                /** @description The shape's id, `shp_…`, as list_shapes returns it. */
                                shapeId: string;
                                /**
                                 * @description One of the tenant's shapes, by id.
                                 * @enum {string}
                                 */
                                type: "shape";
                            };
                            /**
                             * @description Which side of the curve the letters stand on: outside reads clockwise round it (the top of a badge); inside hangs inside it and runs the other way, so text at the bottom reads left to right.
                             * @enum {string}
                             */
                            side: "outside" | "inside";
                            /**
                             * @description Once round a shape's outline, stretched to the layer's box: a closed outline's run is centred where a ray from the box's centre at centerDeg crosses it; an open one runs from its first point.
                             * @enum {string}
                             */
                            type: "outline";
                        };
                        /** @description The layer's rotation, scale and flip, and which of them, and its position, a customer may change. */
                        transform: {
                            /** @description Whether a customer may flip the layer. */
                            flip?: {
                                /** @description A hint shown to the customer under the control. */
                                description?: string;
                                /** @description Whether a customer may change it. */
                                editable: boolean;
                                /** @description What a customer reads the control as. */
                                label?: string;
                            };
                            /** @description Whether, and within what, a customer may resize the layer. */
                            resize?: {
                                /** @description A hint shown to the customer under the control. */
                                description?: string;
                                /** @description Whether a customer may change it. */
                                editable?: boolean;
                                /** @description What a customer reads the control as. */
                                label?: string;
                                /** @description The most height, in millimetres. */
                                maxHMm?: number;
                                /** @description The most width, in millimetres. */
                                maxWMm?: number;
                                /** @description The least height, in millimetres. */
                                minHMm?: number;
                                /** @description The least width, in millimetres. */
                                minWMm?: number;
                            };
                            /** @description Whether, and how far, a customer may rotate the layer. */
                            rotate: {
                                /** @description A hint shown to the customer under the control. */
                                description?: string;
                                /** @description Whether a customer may change it. */
                                editable: boolean;
                                /** @description What a customer reads the control as. */
                                label?: string;
                                /** @description The most rotation, in degrees. */
                                max?: number;
                                /** @description The least rotation, in degrees. */
                                min?: number;
                                /** @description The angle rotation snaps to, in degrees, e.g. 15. */
                                snapDeg?: number;
                            };
                            /** @description Whether, and how far, a customer may scale the layer. */
                            scale: {
                                /** @description A hint shown to the customer under the control. */
                                description?: string;
                                /** @description Whether a customer may change it. */
                                editable: boolean;
                                /** @description What a customer reads the control as. */
                                label?: string;
                                /** @description The most scale; 1 is as authored. */
                                max?: number;
                                /** @description The least scale; 1 is as authored. */
                                min?: number;
                                /** @description The step between the scales a customer may choose. */
                                step?: number;
                            };
                            /** @description Whether, and within what, a customer may move the layer. */
                            translate: {
                                /**
                                 * @description Where a customer's move must keep the layer: inside the safe area (the default), the print box, or anywhere.
                                 * @enum {string}
                                 */
                                bounds?: "safeArea" | "printBox" | "none";
                                /** @description A hint shown to the customer under the control. */
                                description?: string;
                                /** @description Whether a customer may change it. */
                                editable: boolean;
                                /** @description What a customer reads the control as. */
                                label?: string;
                                /** @description What a move snaps to: centre, thirds, safeEdges, layers. */
                                snapTo?: ("centre" | "thirds" | "safeEdges" | "layers")[];
                            };
                            /** @description The layer's rotation, scale and flip. */
                            value: {
                                /** @description Whether the layer is mirrored left to right, about its centre and before its rotation. */
                                flipX?: boolean;
                                /** @description Whether the layer is mirrored top to bottom, about its centre and before its rotation. */
                                flipY?: boolean;
                                /** @description Rotation about the layer's anchor, in degrees, clockwise. */
                                rotationDeg: number;
                                /** @description Scale of the layer; 1 is as authored. */
                                scale: number;
                            };
                        };
                        /** @enum {string} */
                        type: "text";
                        /**
                         * @description true lays spot varnish exactly where the layer is, on a machine that varnishes; it still prints in colour.
                         * @enum {boolean}
                         */
                        varnish?: true;
                        /** @description The layer's width as a fraction of the reference's width. Positive; uncapped, so above 1 hangs over the edge and is clipped. */
                        wFrac: number;
                    };
                    /** @description How many text layers a customer may add, 1 to 20. */
                    max: number;
                };
            };
            /** @description The resolution the artwork is drawn at, in dots per inch; 300 is usual for print. */
            dpi: number;
            /** @description true: the customer's canvas keeps the ratio at every print size, and the print is cropped or banded by fit. Absent is false. */
            drawAtTemplateRatio?: boolean;
            /**
             * @description How the artwork sits in a print box of another shape: contain, cover or fill.
             * @enum {string}
             */
            fit: "contain" | "cover" | "fill";
            form?: {
                /** @enum {string} */
                layout?: "page" | "steps";
            };
            groups?: {
                id: string;
                label: string;
                layerIds: string[];
                order: number;
            }[];
            id: string;
            layers: ({
                /**
                 * @description The point of the reference the layer is placed against, and the layer's own matching point: top-left puts the layer's top-left corner on the reference's.
                 * @enum {string}
                 */
                anchor: "top-left" | "top-center" | "top-right" | "center-left" | "center" | "center-right" | "bottom-left" | "bottom-center" | "bottom-right";
                /** @description Another layer's id, to place and size this one against that layer's box instead of the plate. A missing layer falls back to the plate. */
                anchorTo?: string;
                /**
                 * @description How it mixes with the layers under it, per ink. Absent is normal.
                 * @enum {string}
                 */
                blend?: "multiply" | "screen" | "overlay" | "darken" | "lighten";
                /** @description The layer's height as a fraction of the reference's height. Positive; uncapped, so above 1 hangs over the edge and is clipped. */
                hFrac: number;
                /** @description The layer's id: what anchorTo, groups and a customer's values name it by. Never changes. */
                id: string;
                /**
                 * @description true locks the layer on the author's canvas: clicks pass through and it cannot be deleted. Absent is unlocked.
                 * @enum {boolean}
                 */
                locked?: true;
                /** @description A backdrop painted behind this layer's content at exactly its box: a colour, or a filled shape. Text and image layers only. */
                mat?: {
                    /** @description The backdrop's colour. */
                    color: {
                        /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                        cmyk: [
                            number,
                            number,
                            number,
                            number
                        ];
                    } | {
                        /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                        spot: {
                            /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                            fallback: {
                                /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                cmyk: [
                                    number,
                                    number,
                                    number,
                                    number
                                ];
                            };
                            /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                            name: string;
                            /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                            preview?: {
                                /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                rgb: [
                                    number,
                                    number,
                                    number
                                ];
                            };
                        };
                    } | {
                        /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                        ink: string;
                    } | {
                        /** @description An older spelling of an ink reference; send `{ ink }`. */
                        spot: {
                            /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                            ink: string;
                        };
                    } | {
                        /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                        entry: string;
                        /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                        palette: string;
                    };
                    /**
                     * @description color is a plain backdrop; shape fills a silhouette.
                     * @enum {string}
                     */
                    kind: "color";
                } | {
                    /** @description The silhouette's colour. */
                    fill: {
                        /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                        cmyk: [
                            number,
                            number,
                            number,
                            number
                        ];
                    } | {
                        /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                        spot: {
                            /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                            fallback: {
                                /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                cmyk: [
                                    number,
                                    number,
                                    number,
                                    number
                                ];
                            };
                            /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                            name: string;
                            /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                            preview?: {
                                /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                rgb: [
                                    number,
                                    number,
                                    number
                                ];
                            };
                        };
                    } | {
                        /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                        ink: string;
                    } | {
                        /** @description An older spelling of an ink reference; send `{ ink }`. */
                        spot: {
                            /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                            ink: string;
                        };
                    } | {
                        /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                        entry: string;
                        /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                        palette: string;
                    };
                    /**
                     * @description color is a plain backdrop; shape fills a silhouette.
                     * @enum {string}
                     */
                    kind: "shape";
                    /** @description The backdrop's silhouette, at the layer's box. */
                    shape: {
                        /** @description SVG path data in fractions of its box, (0,0) its top-left and (1,1) its bottom-right: `M 0 0 L 1 0 L 1 1 L 0 1 Z` is the whole box. No arcs. */
                        dFrac: string;
                        /**
                         * @description Inline path geometry.
                         * @enum {string}
                         */
                        type: "path";
                    } | {
                        /** @description The shape's id, `shp_…`, as list_shapes returns it. */
                        shapeId: string;
                        /**
                         * @description One of the tenant's shapes, by id.
                         * @enum {string}
                         */
                        type: "shape";
                    };
                };
                /** @description What the author reads the layer as. Not unique; absent, the layer reads as its id. */
                name?: string;
                /** @description How far the layer sits from its anchor, as fractions of the reference, always toward the reference's centre: { x: 0.05, y: 0.05 } nudges it 5 % in from any corner. Ignored on a centred axis. */
                offsetFrac: {
                    /** @description Across, as a fraction of the reference's width: 0.05 is 5 %. Toward the centre; negative pushes outward. Uncapped. */
                    x: number;
                    /** @description Down or up, as a fraction of the reference's height: 0.05 is 5 %. Toward the centre; negative pushes outward. Uncapped. */
                    y: number;
                };
                /** @description The layer's opacity, which a customer may be offered. Absent is full and not offered. */
                opacity?: {
                    /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                    constraints?: {
                        /** @description The most opacity a customer may choose, 0.01 to 1. */
                        max?: number;
                        /** @description The least opacity a customer may choose, 0.01 to 1. */
                        min?: number;
                        /** @description The step between choosable opacities, e.g. 0.05. */
                        step?: number;
                    };
                    /** @description A hint shown to the customer under the attribute's field. */
                    description?: string;
                    /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                    editable: boolean;
                    /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                    fieldKey?: string;
                    /** @description What a customer reads the attribute as, when editable. */
                    label?: string;
                    /** @description How opaque the whole layer is: 1 is full, 0.01 the least. */
                    value: number;
                };
                /**
                 * @description false makes it a guide layer: laid out and drawn on the author's canvas, never printed or shown to a customer. Absent prints.
                 * @enum {boolean}
                 */
                print?: false;
                props: {
                    /** @description Horizontal alignment in the text box. */
                    align: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most characters a customer may type. */
                            maxLength?: number;
                            /** @description The most lines a customer's text may take. */
                            maxLines?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description Whether a customer must change the template's default (a placeholder name or photo) before a design is accepted. Only on an offered text's content, image's picture, or shape's outline or fill. */
                            requireChange?: boolean;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /**
                         * @description The attribute's value, as the template stores it.
                         * @enum {string}
                         */
                        value: "left" | "center" | "right";
                    };
                    /** @description The text. */
                    content: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most characters a customer may type. */
                            maxLength?: number;
                            /** @description The most lines a customer's text may take. */
                            maxLines?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description Whether a customer must change the template's default (a placeholder name or photo) before a design is accepted. Only on an offered text's content, image's picture, or shape's outline or fill. */
                            requireChange?: boolean;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: string;
                    };
                    /** @description The colour of the text, or a gradient across it. */
                    fill: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /**
                             * @description true lets a customer choose any colour, beside or instead of a palette.
                             * @enum {boolean}
                             */
                            anyColor: true;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                            palette: string;
                        } | {
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                            palette?: string;
                        } | {
                            /**
                             * @description true lets a customer choose any colour, beside or instead of a palette.
                             * @enum {boolean}
                             */
                            anyColor: true;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: {
                            /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                            cmyk: [
                                number,
                                number,
                                number,
                                number
                            ];
                        } | {
                            /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                            spot: {
                                /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                fallback: {
                                    /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                    cmyk: [
                                        number,
                                        number,
                                        number,
                                        number
                                    ];
                                };
                                /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                name: string;
                                /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                preview?: {
                                    /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                    rgb: [
                                        number,
                                        number,
                                        number
                                    ];
                                };
                            };
                        } | {
                            /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                            ink: string;
                        } | {
                            /** @description An older spelling of an ink reference; send `{ ink }`. */
                            spot: {
                                /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                ink: string;
                            };
                        } | {
                            /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                            entry: string;
                            /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                            palette: string;
                        } | {
                            /** @description linear crosses a shape's box or text's letters at an angle; radial from the centre to the farthest corner. */
                            gradient: {
                                /** @description The direction the colours run, in degrees clockwise from straight up: 90 runs left to right, 180 top to bottom. It spans a shape's box or a text's letters. */
                                angleDeg: number;
                                /** @enum {string} */
                                kind: "linear";
                                /** @description The gradient's colours, 2 to 8, in order of position. Blended in CMYK, as the print blends them. */
                                stops: {
                                    /** @description Where the colour sits along the gradient: 0 is its start, 1 its end. Stops are in order; two at one position make a hard edge. */
                                    at: number;
                                    /** @description The colour at this stop: a CMYK colour, one of your inks, or a palette entry. A spot ink cannot be one: a gradient blends process colours. */
                                    color: {
                                        /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                        cmyk: [
                                            number,
                                            number,
                                            number,
                                            number
                                        ];
                                    } | {
                                        /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                                        spot: {
                                            /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                            fallback: {
                                                /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                                cmyk: [
                                                    number,
                                                    number,
                                                    number,
                                                    number
                                                ];
                                            };
                                            /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                            name: string;
                                            /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                            preview?: {
                                                /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                                rgb: [
                                                    number,
                                                    number,
                                                    number
                                                ];
                                            };
                                        };
                                    } | {
                                        /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                        ink: string;
                                    } | {
                                        /** @description An older spelling of an ink reference; send `{ ink }`. */
                                        spot: {
                                            /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                            ink: string;
                                        };
                                    } | {
                                        /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                                        entry: string;
                                        /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                                        palette: string;
                                    };
                                }[];
                            } | {
                                /** @enum {string} */
                                kind: "radial";
                                /** @description The gradient's colours, 2 to 8, in order of position. Blended in CMYK, as the print blends them. */
                                stops: {
                                    /** @description Where the colour sits along the gradient: 0 is its start, 1 its end. Stops are in order; two at one position make a hard edge. */
                                    at: number;
                                    /** @description The colour at this stop: a CMYK colour, one of your inks, or a palette entry. A spot ink cannot be one: a gradient blends process colours. */
                                    color: {
                                        /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                        cmyk: [
                                            number,
                                            number,
                                            number,
                                            number
                                        ];
                                    } | {
                                        /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                                        spot: {
                                            /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                            fallback: {
                                                /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                                cmyk: [
                                                    number,
                                                    number,
                                                    number,
                                                    number
                                                ];
                                            };
                                            /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                            name: string;
                                            /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                            preview?: {
                                                /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                                rgb: [
                                                    number,
                                                    number,
                                                    number
                                                ];
                                            };
                                        };
                                    } | {
                                        /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                        ink: string;
                                    } | {
                                        /** @description An older spelling of an ink reference; send `{ ink }`. */
                                        spot: {
                                            /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                            ink: string;
                                        };
                                    } | {
                                        /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                                        entry: string;
                                        /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                                        palette: string;
                                    };
                                }[];
                            };
                        };
                    };
                    /** @description The font family, one of those the tenant offers. */
                    fontFamily: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most characters a customer may type. */
                            maxLength?: number;
                            /** @description The most lines a customer's text may take. */
                            maxLines?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description Whether a customer must change the template's default (a placeholder name or photo) before a design is accepted. Only on an offered text's content, image's picture, or shape's outline or fill. */
                            requireChange?: boolean;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: string;
                    };
                    /** @description The font size as a fraction of the plate's HEIGHT, as is its offered range: 0.05 is 5 % of the height. Positive. */
                    fontSizeFrac: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most value a customer may choose. */
                            max?: number;
                            /** @description The least value a customer may choose. */
                            min?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The step between the values a customer may choose. */
                            step?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: number;
                    };
                    /** @description Upright (normal) or italic; absent is normal. An italic text draws its font's italic faces, or its upright ones when the font has none. Set by the author: a customer is not offered it. */
                    fontStyle?: {
                        /**
                         * @description Always false: the author sets it, a customer may not.
                         * @enum {boolean}
                         */
                        editable: false;
                        /**
                         * @description The attribute's value, as the template stores it.
                         * @enum {string}
                         */
                        value: "normal" | "italic";
                    };
                    /** @description The font weight, 1 to 1000; 400 is regular, 700 bold. */
                    fontWeight?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most value a customer may choose. */
                            max?: number;
                            /** @description The least value a customer may choose. */
                            min?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The step between the values a customer may choose. */
                            step?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: number;
                    };
                    /** @description The space added after each letter, as a fraction of the drawn text size (0.1 is a tenth of it), -0.1 to 1; absent or 0 is the font's own spacing. */
                    letterSpacingEm?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most value a customer may choose. */
                            max?: number;
                            /** @description The least value a customer may choose. */
                            min?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The step between the values a customer may choose. */
                            step?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: number;
                    };
                    /** @description The line spacing as a multiple of the font's own, 0.5 to 3; absent or 1 is the font's own. */
                    lineHeight?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most value a customer may choose. */
                            max?: number;
                            /** @description The least value a customer may choose. */
                            min?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The step between the values a customer may choose. */
                            step?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: number;
                    };
                    /** @description The colour of the line drawn around every letter, outside its fill; absent is black. */
                    outlineColor?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /**
                             * @description true lets a customer choose any colour, beside or instead of a palette.
                             * @enum {boolean}
                             */
                            anyColor: true;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                            palette: string;
                        } | {
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                            palette?: string;
                        } | {
                            /**
                             * @description true lets a customer choose any colour, beside or instead of a palette.
                             * @enum {boolean}
                             */
                            anyColor: true;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: {
                            /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                            cmyk: [
                                number,
                                number,
                                number,
                                number
                            ];
                        } | {
                            /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                            spot: {
                                /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                fallback: {
                                    /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                    cmyk: [
                                        number,
                                        number,
                                        number,
                                        number
                                    ];
                                };
                                /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                name: string;
                                /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                preview?: {
                                    /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                    rgb: [
                                        number,
                                        number,
                                        number
                                    ];
                                };
                            };
                        } | {
                            /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                            ink: string;
                        } | {
                            /** @description An older spelling of an ink reference; send `{ ink }`. */
                            spot: {
                                /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                ink: string;
                            };
                        } | {
                            /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                            entry: string;
                            /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                            palette: string;
                        };
                    };
                    /** @description The outline's width as a fraction of the drawn text size (0.05 is a twentieth of it), 0 to 0.25; absent or 0 draws no outline. */
                    outlineWidthEm?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most value a customer may choose. */
                            max?: number;
                            /** @description The least value a customer may choose. */
                            min?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The step between the values a customer may choose. */
                            step?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: number;
                    };
                    /** @description How soft the shadow is: its blur radius as a fraction of the drawn text size, 0 (sharp) to 1. A shadow with no offset and no blur draws nothing. */
                    shadowBlurEm?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most value a customer may choose. */
                            max?: number;
                            /** @description The least value a customer may choose. */
                            min?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The step between the values a customer may choose. */
                            step?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: number;
                    };
                    /** @description The colour of the shadow drawn under the text; absent is black. */
                    shadowColor?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /**
                             * @description true lets a customer choose any colour, beside or instead of a palette.
                             * @enum {boolean}
                             */
                            anyColor: true;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                            palette: string;
                        } | {
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                            palette?: string;
                        } | {
                            /**
                             * @description true lets a customer choose any colour, beside or instead of a palette.
                             * @enum {boolean}
                             */
                            anyColor: true;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: {
                            /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                            cmyk: [
                                number,
                                number,
                                number,
                                number
                            ];
                        } | {
                            /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                            spot: {
                                /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                fallback: {
                                    /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                    cmyk: [
                                        number,
                                        number,
                                        number,
                                        number
                                    ];
                                };
                                /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                name: string;
                                /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                preview?: {
                                    /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                    rgb: [
                                        number,
                                        number,
                                        number
                                    ];
                                };
                            };
                        } | {
                            /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                            ink: string;
                        } | {
                            /** @description An older spelling of an ink reference; send `{ ink }`. */
                            spot: {
                                /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                ink: string;
                            };
                        } | {
                            /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                            entry: string;
                            /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                            palette: string;
                        };
                    };
                    /** @description How far right the shadow falls, as a fraction of the drawn text size, -1 to 1; negative is left. */
                    shadowOffsetXEm?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most value a customer may choose. */
                            max?: number;
                            /** @description The least value a customer may choose. */
                            min?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The step between the values a customer may choose. */
                            step?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: number;
                    };
                    /** @description How far down the shadow falls, as a fraction of the drawn text size, -1 to 1; negative is up. */
                    shadowOffsetYEm?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most value a customer may choose. */
                            max?: number;
                            /** @description The least value a customer may choose. */
                            min?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The step between the values a customer may choose. */
                            step?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: number;
                    };
                    /** @description How the letters are cased when drawn: asTyped, upper, lower or title (each word's first letter a capital). The text itself is kept as typed. Absent is asTyped. */
                    textCase?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most characters a customer may type. */
                            maxLength?: number;
                            /** @description The most lines a customer's text may take. */
                            maxLines?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description Whether a customer must change the template's default (a placeholder name or photo) before a design is accepted. Only on an offered text's content, image's picture, or shape's outline or fill. */
                            requireChange?: boolean;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /**
                         * @description The attribute's value, as the template stores it.
                         * @enum {string}
                         */
                        value: "asTyped" | "upper" | "lower" | "title";
                    };
                    /** @description Vertical alignment in the text box; absent is middle. */
                    valign?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most characters a customer may type. */
                            maxLength?: number;
                            /** @description The most lines a customer's text may take. */
                            maxLines?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description Whether a customer must change the template's default (a placeholder name or photo) before a design is accepted. Only on an offered text's content, image's picture, or shape's outline or fill. */
                            requireChange?: boolean;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /**
                         * @description The attribute's value, as the template stores it.
                         * @enum {string}
                         */
                        value: "top" | "middle" | "bottom";
                    };
                };
                /** @description What the text layer does when its text does not fit its box. Every size here is a fraction of the plate. */
                textBox: {
                    /**
                     * @description true breaks a word wider than the box across lines rather than refusing it.
                     * @enum {boolean}
                     */
                    breakWords?: true;
                    /**
                     * @description adapt keeps the font size and grows the box, then shrinks the text, as far as the limits below allow.
                     * @enum {string}
                     */
                    mode: "adapt";
                    /**
                     * @description Which way the box grows first. Absent is widerFirst.
                     * @enum {string}
                     */
                    order?: "widerFirst" | "tallerFirst";
                    /** @description The smallest font size the text may shrink to, as a fraction of the plate's height. Absent, it does not shrink. */
                    shrinkTo?: number;
                    /** @description How tall the box may grow, as a fraction of the plate's height, at most 1. Absent, it does not grow taller. */
                    tallerTo?: number;
                    /**
                     * @description What happens to text that still does not fit: clamp cuts it at the box, reject refuses the text.
                     * @enum {string}
                     */
                    then: "clamp" | "reject";
                    /** @description How wide the box may grow, as a fraction of the plate's width, at most 1. Absent, it does not widen. */
                    widenTo?: number;
                } | {
                    /**
                     * @description true breaks a word wider than the box across lines rather than refusing it.
                     * @enum {boolean}
                     */
                    breakWords?: true;
                    /** @description The largest font size, as a fraction of the plate's height; null is no limit, as large as one line of the box. */
                    max: number | null;
                    /** @description The smallest font size, as a fraction of the plate's height. */
                    min: number;
                    /**
                     * @description fill sizes the text to fill the box, between min and max.
                     * @enum {string}
                     */
                    mode: "fill";
                    /**
                     * @description What happens to text that still does not fit: clamp cuts it at the box, reject refuses the text.
                     * @enum {string}
                     */
                    then: "clamp" | "reject";
                };
                /** @description A curve the text runs along, as one line: absent is straight lines. The text box still fits it along the curve's length: it shrinks, then is cut or refused, never widening or growing taller. */
                textPath?: {
                    /** @description Where the text's run is centred, in degrees clockwise from 12 o'clock: 0 is the top, 90 the right, 180 the bottom. */
                    centerDeg: number;
                    /**
                     * @description Which side of the curve the letters stand on: outside reads clockwise round it (the top of a badge); inside hangs inside it and runs the other way, so text at the bottom reads left to right.
                     * @enum {string}
                     */
                    side: "outside" | "inside";
                    /** @description How much of the oval the arc covers, in degrees, above 0 and at most 360: 360 is a whole circle. */
                    sweepDeg: number;
                    /**
                     * @description Along the oval inside the layer's box, a circle when the box is square: the box is the radius.
                     * @enum {string}
                     */
                    type: "arc";
                } | {
                    /** @description Where the text's run is centred, in degrees clockwise from 12 o'clock: 0 is the top, 90 the right, 180 the bottom. */
                    centerDeg: number;
                    shape: {
                        /** @description SVG path data in fractions of its box, (0,0) its top-left and (1,1) its bottom-right: `M 0 0 L 1 0 L 1 1 L 0 1 Z` is the whole box. No arcs. */
                        dFrac: string;
                        /**
                         * @description Inline path geometry.
                         * @enum {string}
                         */
                        type: "path";
                    } | {
                        /** @description The shape's id, `shp_…`, as list_shapes returns it. */
                        shapeId: string;
                        /**
                         * @description One of the tenant's shapes, by id.
                         * @enum {string}
                         */
                        type: "shape";
                    };
                    /**
                     * @description Which side of the curve the letters stand on: outside reads clockwise round it (the top of a badge); inside hangs inside it and runs the other way, so text at the bottom reads left to right.
                     * @enum {string}
                     */
                    side: "outside" | "inside";
                    /**
                     * @description Once round a shape's outline, stretched to the layer's box: a closed outline's run is centred where a ray from the box's centre at centerDeg crosses it; an open one runs from its first point.
                     * @enum {string}
                     */
                    type: "outline";
                };
                /** @description The layer's rotation, scale and flip, and which of them, and its position, a customer may change. */
                transform: {
                    /** @description Whether a customer may flip the layer. */
                    flip?: {
                        /** @description A hint shown to the customer under the control. */
                        description?: string;
                        /** @description Whether a customer may change it. */
                        editable: boolean;
                        /** @description What a customer reads the control as. */
                        label?: string;
                    };
                    /** @description Whether, and within what, a customer may resize the layer. */
                    resize?: {
                        /** @description A hint shown to the customer under the control. */
                        description?: string;
                        /** @description Whether a customer may change it. */
                        editable?: boolean;
                        /** @description What a customer reads the control as. */
                        label?: string;
                        /** @description The most height, in millimetres. */
                        maxHMm?: number;
                        /** @description The most width, in millimetres. */
                        maxWMm?: number;
                        /** @description The least height, in millimetres. */
                        minHMm?: number;
                        /** @description The least width, in millimetres. */
                        minWMm?: number;
                    };
                    /** @description Whether, and how far, a customer may rotate the layer. */
                    rotate: {
                        /** @description A hint shown to the customer under the control. */
                        description?: string;
                        /** @description Whether a customer may change it. */
                        editable: boolean;
                        /** @description What a customer reads the control as. */
                        label?: string;
                        /** @description The most rotation, in degrees. */
                        max?: number;
                        /** @description The least rotation, in degrees. */
                        min?: number;
                        /** @description The angle rotation snaps to, in degrees, e.g. 15. */
                        snapDeg?: number;
                    };
                    /** @description Whether, and how far, a customer may scale the layer. */
                    scale: {
                        /** @description A hint shown to the customer under the control. */
                        description?: string;
                        /** @description Whether a customer may change it. */
                        editable: boolean;
                        /** @description What a customer reads the control as. */
                        label?: string;
                        /** @description The most scale; 1 is as authored. */
                        max?: number;
                        /** @description The least scale; 1 is as authored. */
                        min?: number;
                        /** @description The step between the scales a customer may choose. */
                        step?: number;
                    };
                    /** @description Whether, and within what, a customer may move the layer. */
                    translate: {
                        /**
                         * @description Where a customer's move must keep the layer: inside the safe area (the default), the print box, or anywhere.
                         * @enum {string}
                         */
                        bounds?: "safeArea" | "printBox" | "none";
                        /** @description A hint shown to the customer under the control. */
                        description?: string;
                        /** @description Whether a customer may change it. */
                        editable: boolean;
                        /** @description What a customer reads the control as. */
                        label?: string;
                        /** @description What a move snaps to: centre, thirds, safeEdges, layers. */
                        snapTo?: ("centre" | "thirds" | "safeEdges" | "layers")[];
                    };
                    /** @description The layer's rotation, scale and flip. */
                    value: {
                        /** @description Whether the layer is mirrored left to right, about its centre and before its rotation. */
                        flipX?: boolean;
                        /** @description Whether the layer is mirrored top to bottom, about its centre and before its rotation. */
                        flipY?: boolean;
                        /** @description Rotation about the layer's anchor, in degrees, clockwise. */
                        rotationDeg: number;
                        /** @description Scale of the layer; 1 is as authored. */
                        scale: number;
                    };
                };
                /** @enum {string} */
                type: "text";
                /**
                 * @description true lays spot varnish exactly where the layer is, on a machine that varnishes; it still prints in colour.
                 * @enum {boolean}
                 */
                varnish?: true;
                /** @description The layer's width as a fraction of the reference's width. Positive; uncapped, so above 1 hangs over the edge and is clipped. */
                wFrac: number;
                /** @description Paint depth, lowest painted first. A multiple of 10 follows the layer's place in the list; any other value pins it. */
                z: number;
            } | {
                /**
                 * @description The point of the reference the layer is placed against, and the layer's own matching point: top-left puts the layer's top-left corner on the reference's.
                 * @enum {string}
                 */
                anchor: "top-left" | "top-center" | "top-right" | "center-left" | "center" | "center-right" | "bottom-left" | "bottom-center" | "bottom-right";
                /** @description Another layer's id, to place and size this one against that layer's box instead of the plate. A missing layer falls back to the plate. */
                anchorTo?: string;
                /**
                 * @description How it mixes with the layers under it, per ink. Absent is normal.
                 * @enum {string}
                 */
                blend?: "multiply" | "screen" | "overlay" | "darken" | "lighten";
                /** @description The layer's height as a fraction of the reference's height. Positive; uncapped, so above 1 hangs over the edge and is clipped. */
                hFrac: number;
                /** @description The layer's id: what anchorTo, groups and a customer's values name it by. Never changes. */
                id: string;
                /**
                 * @description true locks the layer on the author's canvas: clicks pass through and it cannot be deleted. Absent is unlocked.
                 * @enum {boolean}
                 */
                locked?: true;
                /** @description A backdrop painted behind this layer's content at exactly its box: a colour, or a filled shape. Text and image layers only. */
                mat?: {
                    /** @description The backdrop's colour. */
                    color: {
                        /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                        cmyk: [
                            number,
                            number,
                            number,
                            number
                        ];
                    } | {
                        /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                        spot: {
                            /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                            fallback: {
                                /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                cmyk: [
                                    number,
                                    number,
                                    number,
                                    number
                                ];
                            };
                            /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                            name: string;
                            /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                            preview?: {
                                /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                rgb: [
                                    number,
                                    number,
                                    number
                                ];
                            };
                        };
                    } | {
                        /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                        ink: string;
                    } | {
                        /** @description An older spelling of an ink reference; send `{ ink }`. */
                        spot: {
                            /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                            ink: string;
                        };
                    } | {
                        /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                        entry: string;
                        /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                        palette: string;
                    };
                    /**
                     * @description color is a plain backdrop; shape fills a silhouette.
                     * @enum {string}
                     */
                    kind: "color";
                } | {
                    /** @description The silhouette's colour. */
                    fill: {
                        /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                        cmyk: [
                            number,
                            number,
                            number,
                            number
                        ];
                    } | {
                        /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                        spot: {
                            /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                            fallback: {
                                /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                cmyk: [
                                    number,
                                    number,
                                    number,
                                    number
                                ];
                            };
                            /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                            name: string;
                            /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                            preview?: {
                                /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                rgb: [
                                    number,
                                    number,
                                    number
                                ];
                            };
                        };
                    } | {
                        /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                        ink: string;
                    } | {
                        /** @description An older spelling of an ink reference; send `{ ink }`. */
                        spot: {
                            /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                            ink: string;
                        };
                    } | {
                        /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                        entry: string;
                        /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                        palette: string;
                    };
                    /**
                     * @description color is a plain backdrop; shape fills a silhouette.
                     * @enum {string}
                     */
                    kind: "shape";
                    /** @description The backdrop's silhouette, at the layer's box. */
                    shape: {
                        /** @description SVG path data in fractions of its box, (0,0) its top-left and (1,1) its bottom-right: `M 0 0 L 1 0 L 1 1 L 0 1 Z` is the whole box. No arcs. */
                        dFrac: string;
                        /**
                         * @description Inline path geometry.
                         * @enum {string}
                         */
                        type: "path";
                    } | {
                        /** @description The shape's id, `shp_…`, as list_shapes returns it. */
                        shapeId: string;
                        /**
                         * @description One of the tenant's shapes, by id.
                         * @enum {string}
                         */
                        type: "shape";
                    };
                };
                /** @description What the author reads the layer as. Not unique; absent, the layer reads as its id. */
                name?: string;
                /** @description How far the layer sits from its anchor, as fractions of the reference, always toward the reference's centre: { x: 0.05, y: 0.05 } nudges it 5 % in from any corner. Ignored on a centred axis. */
                offsetFrac: {
                    /** @description Across, as a fraction of the reference's width: 0.05 is 5 %. Toward the centre; negative pushes outward. Uncapped. */
                    x: number;
                    /** @description Down or up, as a fraction of the reference's height: 0.05 is 5 %. Toward the centre; negative pushes outward. Uncapped. */
                    y: number;
                };
                /** @description The layer's opacity, which a customer may be offered. Absent is full and not offered. */
                opacity?: {
                    /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                    constraints?: {
                        /** @description The most opacity a customer may choose, 0.01 to 1. */
                        max?: number;
                        /** @description The least opacity a customer may choose, 0.01 to 1. */
                        min?: number;
                        /** @description The step between choosable opacities, e.g. 0.05. */
                        step?: number;
                    };
                    /** @description A hint shown to the customer under the attribute's field. */
                    description?: string;
                    /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                    editable: boolean;
                    /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                    fieldKey?: string;
                    /** @description What a customer reads the attribute as, when editable. */
                    label?: string;
                    /** @description How opaque the whole layer is: 1 is full, 0.01 the least. */
                    value: number;
                };
                /**
                 * @description false makes it a guide layer: laid out and drawn on the author's canvas, never printed or shown to a customer. Absent prints.
                 * @enum {boolean}
                 */
                print?: false;
                props: {
                    /** @description How much lighter (up to 1) or darker (down to -1) the photo is drawn; absent or 0 is as uploaded. */
                    brightness?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most value a customer may choose. */
                            max?: number;
                            /** @description The least value a customer may choose. */
                            min?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The step between the values a customer may choose. */
                            step?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: number;
                    };
                    /** @description How far the photo's tones are pushed apart (up to 1) or pulled toward middle grey (down to -1); absent or 0 is as uploaded. */
                    contrast?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most value a customer may choose. */
                            max?: number;
                            /** @description The least value a customer may choose. */
                            min?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The step between the values a customer may choose. */
                            step?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: number;
                    };
                    /** @description How round the picture's corners are: their radius as a fraction of the shorter side of the layer's box, 0 (square) to 0.5 (a square box becomes a circle). The outline and the shadow follow it. */
                    cornerRadiusShortSide?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most value a customer may choose. */
                            max?: number;
                            /** @description The least value a customer may choose. */
                            min?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The step between the values a customer may choose. */
                            step?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: number;
                    };
                    /** @description Where the picture sits in its frame, under cover. Absent is uncropped. */
                    crop?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most zoom a customer may choose; absent is 3. */
                            maxZoom?: number;
                            /** @description The least zoom a customer may choose; absent is 1. */
                            minZoom?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: {
                            /** @description How far the picture's centre sits right of the frame's centre, in frame widths: 0.1 is a tenth of the frame. Clamped so the picture always covers the frame, never refused. */
                            xFrac: number;
                            /** @description How far the picture's centre sits below the frame's centre, in frame heights: 0.1 is a tenth of the frame. Clamped so the picture always covers the frame, never refused. */
                            yFrac: number;
                            /** @description The picture's scale over what cover gives it: 1 is the picture just covering the frame, up to 5. */
                            zoom: number;
                        };
                    };
                    /** @description The colour a duotone photo's lightest tones become; absent is paper white. A process colour: a spot ink is refused. */
                    duotoneHighlight?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /**
                             * @description true lets a customer choose any colour, beside or instead of a palette.
                             * @enum {boolean}
                             */
                            anyColor: true;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                            palette: string;
                        } | {
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                            palette?: string;
                        } | {
                            /**
                             * @description true lets a customer choose any colour, beside or instead of a palette.
                             * @enum {boolean}
                             */
                            anyColor: true;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: {
                            /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                            cmyk: [
                                number,
                                number,
                                number,
                                number
                            ];
                        } | {
                            /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                            spot: {
                                /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                fallback: {
                                    /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                    cmyk: [
                                        number,
                                        number,
                                        number,
                                        number
                                    ];
                                };
                                /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                name: string;
                                /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                preview?: {
                                    /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                    rgb: [
                                        number,
                                        number,
                                        number
                                    ];
                                };
                            };
                        } | {
                            /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                            ink: string;
                        } | {
                            /** @description An older spelling of an ink reference; send `{ ink }`. */
                            spot: {
                                /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                ink: string;
                            };
                        } | {
                            /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                            entry: string;
                            /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                            palette: string;
                        };
                    };
                    /** @description The colour a duotone photo's darkest tones become; absent is black. A process colour: a spot ink is refused. */
                    duotoneShadow?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /**
                             * @description true lets a customer choose any colour, beside or instead of a palette.
                             * @enum {boolean}
                             */
                            anyColor: true;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                            palette: string;
                        } | {
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                            palette?: string;
                        } | {
                            /**
                             * @description true lets a customer choose any colour, beside or instead of a palette.
                             * @enum {boolean}
                             */
                            anyColor: true;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: {
                            /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                            cmyk: [
                                number,
                                number,
                                number,
                                number
                            ];
                        } | {
                            /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                            spot: {
                                /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                fallback: {
                                    /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                    cmyk: [
                                        number,
                                        number,
                                        number,
                                        number
                                    ];
                                };
                                /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                name: string;
                                /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                preview?: {
                                    /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                    rgb: [
                                        number,
                                        number,
                                        number
                                    ];
                                };
                            };
                        } | {
                            /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                            ink: string;
                        } | {
                            /** @description An older spelling of an ink reference; send `{ ink }`. */
                            spot: {
                                /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                ink: string;
                            };
                        } | {
                            /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                            entry: string;
                            /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                            palette: string;
                        };
                    };
                    /** @description What the outline and the shadow are cast from: box (the layer's box, rounded by its corners) or picture (the picture's own visible pixels, so a cut-out casts its own shape). An image with a colour mat follows its box. Absent is box. */
                    effectsFollow?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /**
                         * @description The attribute's value, as the template stores it.
                         * @enum {string}
                         */
                        value: "box" | "picture";
                    };
                    /** @description How the picture fills its box: cover crops, contain shows it whole, fill stretches, tile repeats it. Absent is cover. */
                    fit: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /**
                         * @description The attribute's value, as the template stores it.
                         * @enum {string}
                         */
                        value: "contain" | "cover" | "fill" | "tile";
                    };
                    /** @description The colour of the image's outline, whichever width draws it: absent is black under outlineWidthShortSide, and white, a sticker's edge, under outlineWidthShare. */
                    outlineColor?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /**
                             * @description true lets a customer choose any colour, beside or instead of a palette.
                             * @enum {boolean}
                             */
                            anyColor: true;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                            palette: string;
                        } | {
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                            palette?: string;
                        } | {
                            /**
                             * @description true lets a customer choose any colour, beside or instead of a palette.
                             * @enum {boolean}
                             */
                            anyColor: true;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: {
                            /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                            cmyk: [
                                number,
                                number,
                                number,
                                number
                            ];
                        } | {
                            /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                            spot: {
                                /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                fallback: {
                                    /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                    cmyk: [
                                        number,
                                        number,
                                        number,
                                        number
                                    ];
                                };
                                /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                name: string;
                                /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                preview?: {
                                    /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                    rgb: [
                                        number,
                                        number,
                                        number
                                    ];
                                };
                            };
                        } | {
                            /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                            ink: string;
                        } | {
                            /** @description An older spelling of an ink reference; send `{ ink }`. */
                            spot: {
                                /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                ink: string;
                            };
                        } | {
                            /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                            entry: string;
                            /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                            palette: string;
                        };
                    };
                    /** @description The width of an outline drawn round the picture's own pixels, like a sticker's edge, as a fraction of the picture box's shorter side (0.02 is a fiftieth of it), 0 to 0.1; absent or 0 draws no outline. Not drawn on a tiled picture. An image sets this or outlineWidthShortSide, never both. */
                    outlineWidthShare?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most value a customer may choose. */
                            max?: number;
                            /** @description The least value a customer may choose. */
                            min?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The step between the values a customer may choose. */
                            step?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: number;
                    };
                    /** @description The outline's width as a fraction of the shorter side of the layer's box (0.02 is a fiftieth of it), 0 to 0.1; absent or 0 draws no outline. On an image, traced round its box or its picture (effectsFollow); an image sets this or outlineWidthShare, never both. */
                    outlineWidthShortSide?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most value a customer may choose. */
                            max?: number;
                            /** @description The least value a customer may choose. */
                            min?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The step between the values a customer may choose. */
                            step?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: number;
                    };
                    /** @description How far the photo's colours are strengthened (up to 1) or pulled toward grey (down to -1); absent or 0 is as uploaded. A tone other than none draws no colour of the photo's own, so saturation then changes nothing. */
                    saturation?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most value a customer may choose. */
                            max?: number;
                            /** @description The least value a customer may choose. */
                            min?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The step between the values a customer may choose. */
                            step?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: number;
                    };
                    /** @description How soft the shadow is: its blur radius as a fraction of the shorter side of the layer's box, 0 (sharp) to 0.25. A shadow with no offset and no blur draws nothing. */
                    shadowBlurShortSide?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most value a customer may choose. */
                            max?: number;
                            /** @description The least value a customer may choose. */
                            min?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The step between the values a customer may choose. */
                            step?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: number;
                    };
                    /** @description The colour of the shadow drawn under the layer; absent is black. */
                    shadowColor?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /**
                             * @description true lets a customer choose any colour, beside or instead of a palette.
                             * @enum {boolean}
                             */
                            anyColor: true;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                            palette: string;
                        } | {
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                            palette?: string;
                        } | {
                            /**
                             * @description true lets a customer choose any colour, beside or instead of a palette.
                             * @enum {boolean}
                             */
                            anyColor: true;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: {
                            /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                            cmyk: [
                                number,
                                number,
                                number,
                                number
                            ];
                        } | {
                            /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                            spot: {
                                /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                fallback: {
                                    /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                    cmyk: [
                                        number,
                                        number,
                                        number,
                                        number
                                    ];
                                };
                                /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                name: string;
                                /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                preview?: {
                                    /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                    rgb: [
                                        number,
                                        number,
                                        number
                                    ];
                                };
                            };
                        } | {
                            /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                            ink: string;
                        } | {
                            /** @description An older spelling of an ink reference; send `{ ink }`. */
                            spot: {
                                /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                ink: string;
                            };
                        } | {
                            /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                            entry: string;
                            /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                            palette: string;
                        };
                    };
                    /** @description How far right the shadow falls, as a fraction of the shorter side of the layer's box, -0.25 to 0.25; negative is left. */
                    shadowOffsetXShortSide?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most value a customer may choose. */
                            max?: number;
                            /** @description The least value a customer may choose. */
                            min?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The step between the values a customer may choose. */
                            step?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: number;
                    };
                    /** @description How far down the shadow falls, as a fraction of the shorter side of the layer's box, -0.25 to 0.25; negative is up. */
                    shadowOffsetYShortSide?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most value a customer may choose. */
                            max?: number;
                            /** @description The least value a customer may choose. */
                            min?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The step between the values a customer may choose. */
                            step?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: number;
                    };
                    /** @description The picture's asset id; null is none chosen yet. */
                    src: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description Whether a customer may upload a picture of their own. */
                            allowUpload?: boolean;
                            /**
                             * @description true cuts a customer's upload out onto a transparent background, as a new upload in its place paid from the tenant's credits; one that fails leaves their photo as it was. Absent, never.
                             * @enum {boolean}
                             */
                            cutOut?: true;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description Whether a customer must change the template's default (a placeholder name or photo) before a design is accepted. Only on an offered text's content, image's picture, or shape's outline or fill. */
                            requireChange?: boolean;
                            /** @description Whether a customer must choose a picture. */
                            required?: boolean;
                            /** @description Present, an upload below `belowDpi` at the customer's chosen size is offered an upscale to `toDpi` before the proof, paid from the tenant's credits. Absent, never. */
                            upscale?: {
                                /** @description The print resolution, in dots per inch, below which an upload is offered an upscale. Absent, the template's minimum, else the tenant's. */
                                belowDpi?: number;
                                /** @description The print resolution, in dots per inch, an upload is upscaled to, and priced by: under `belowDpi`, at it or past it. Absent, `belowDpi`. */
                                toDpi?: number;
                            };
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: string | null;
                    };
                    /** @description The tile's size against the picture's own, when the fit is tile. */
                    tileScale?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The largest tile scale a customer may choose. */
                            max?: number;
                            /** @description The smallest tile scale a customer may choose. */
                            min?: number;
                            /** @description The step between the tile scales a customer may choose. */
                            step?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: number;
                    };
                    /** @description What the photo's lightness is mapped onto, after brightness, contrast and saturation: none (its own colours), blackAndWhite, sepia, or duotone (from duotoneShadow in its darkest tones to duotoneHighlight in its lightest). Absent is none. */
                    tone?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /**
                         * @description The attribute's value, as the template stores it.
                         * @enum {string}
                         */
                        value: "none" | "blackAndWhite" | "sepia" | "duotone";
                    };
                };
                /** @description The layer's rotation, scale and flip, and which of them, and its position, a customer may change. */
                transform: {
                    /** @description Whether a customer may flip the layer. */
                    flip?: {
                        /** @description A hint shown to the customer under the control. */
                        description?: string;
                        /** @description Whether a customer may change it. */
                        editable: boolean;
                        /** @description What a customer reads the control as. */
                        label?: string;
                    };
                    /** @description Whether, and within what, a customer may resize the layer. */
                    resize?: {
                        /** @description A hint shown to the customer under the control. */
                        description?: string;
                        /** @description Whether a customer may change it. */
                        editable?: boolean;
                        /** @description What a customer reads the control as. */
                        label?: string;
                        /** @description The most height, in millimetres. */
                        maxHMm?: number;
                        /** @description The most width, in millimetres. */
                        maxWMm?: number;
                        /** @description The least height, in millimetres. */
                        minHMm?: number;
                        /** @description The least width, in millimetres. */
                        minWMm?: number;
                    };
                    /** @description Whether, and how far, a customer may rotate the layer. */
                    rotate: {
                        /** @description A hint shown to the customer under the control. */
                        description?: string;
                        /** @description Whether a customer may change it. */
                        editable: boolean;
                        /** @description What a customer reads the control as. */
                        label?: string;
                        /** @description The most rotation, in degrees. */
                        max?: number;
                        /** @description The least rotation, in degrees. */
                        min?: number;
                        /** @description The angle rotation snaps to, in degrees, e.g. 15. */
                        snapDeg?: number;
                    };
                    /** @description Whether, and how far, a customer may scale the layer. */
                    scale: {
                        /** @description A hint shown to the customer under the control. */
                        description?: string;
                        /** @description Whether a customer may change it. */
                        editable: boolean;
                        /** @description What a customer reads the control as. */
                        label?: string;
                        /** @description The most scale; 1 is as authored. */
                        max?: number;
                        /** @description The least scale; 1 is as authored. */
                        min?: number;
                        /** @description The step between the scales a customer may choose. */
                        step?: number;
                    };
                    /** @description Whether, and within what, a customer may move the layer. */
                    translate: {
                        /**
                         * @description Where a customer's move must keep the layer: inside the safe area (the default), the print box, or anywhere.
                         * @enum {string}
                         */
                        bounds?: "safeArea" | "printBox" | "none";
                        /** @description A hint shown to the customer under the control. */
                        description?: string;
                        /** @description Whether a customer may change it. */
                        editable: boolean;
                        /** @description What a customer reads the control as. */
                        label?: string;
                        /** @description What a move snaps to: centre, thirds, safeEdges, layers. */
                        snapTo?: ("centre" | "thirds" | "safeEdges" | "layers")[];
                    };
                    /** @description The layer's rotation, scale and flip. */
                    value: {
                        /** @description Whether the layer is mirrored left to right, about its centre and before its rotation. */
                        flipX?: boolean;
                        /** @description Whether the layer is mirrored top to bottom, about its centre and before its rotation. */
                        flipY?: boolean;
                        /** @description Rotation about the layer's anchor, in degrees, clockwise. */
                        rotationDeg: number;
                        /** @description Scale of the layer; 1 is as authored. */
                        scale: number;
                    };
                };
                /** @enum {string} */
                type: "image";
                /**
                 * @description true lays spot varnish exactly where the layer is, on a machine that varnishes; it still prints in colour.
                 * @enum {boolean}
                 */
                varnish?: true;
                /** @description The layer's width as a fraction of the reference's width. Positive; uncapped, so above 1 hangs over the edge and is clipped. */
                wFrac: number;
                /** @description Paint depth, lowest painted first. A multiple of 10 follows the layer's place in the list; any other value pins it. */
                z: number;
            } | {
                /**
                 * @description The point of the reference the layer is placed against, and the layer's own matching point: top-left puts the layer's top-left corner on the reference's.
                 * @enum {string}
                 */
                anchor: "top-left" | "top-center" | "top-right" | "center-left" | "center" | "center-right" | "bottom-left" | "bottom-center" | "bottom-right";
                /** @description Another layer's id, to place and size this one against that layer's box instead of the plate. A missing layer falls back to the plate. */
                anchorTo?: string;
                /**
                 * @description How it mixes with the layers under it, per ink. Absent is normal.
                 * @enum {string}
                 */
                blend?: "multiply" | "screen" | "overlay" | "darken" | "lighten";
                /** @description The layer's height as a fraction of the reference's height. Positive; uncapped, so above 1 hangs over the edge and is clipped. */
                hFrac: number;
                /** @description The layer's id: what anchorTo, groups and a customer's values name it by. Never changes. */
                id: string;
                /**
                 * @description true locks the layer on the author's canvas: clicks pass through and it cannot be deleted. Absent is unlocked.
                 * @enum {boolean}
                 */
                locked?: true;
                /** @description What the author reads the layer as. Not unique; absent, the layer reads as its id. */
                name?: string;
                /** @description How far the layer sits from its anchor, as fractions of the reference, always toward the reference's centre: { x: 0.05, y: 0.05 } nudges it 5 % in from any corner. Ignored on a centred axis. */
                offsetFrac: {
                    /** @description Across, as a fraction of the reference's width: 0.05 is 5 %. Toward the centre; negative pushes outward. Uncapped. */
                    x: number;
                    /** @description Down or up, as a fraction of the reference's height: 0.05 is 5 %. Toward the centre; negative pushes outward. Uncapped. */
                    y: number;
                };
                /** @description The layer's opacity, which a customer may be offered. Absent is full and not offered. */
                opacity?: {
                    /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                    constraints?: {
                        /** @description The most opacity a customer may choose, 0.01 to 1. */
                        max?: number;
                        /** @description The least opacity a customer may choose, 0.01 to 1. */
                        min?: number;
                        /** @description The step between choosable opacities, e.g. 0.05. */
                        step?: number;
                    };
                    /** @description A hint shown to the customer under the attribute's field. */
                    description?: string;
                    /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                    editable: boolean;
                    /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                    fieldKey?: string;
                    /** @description What a customer reads the attribute as, when editable. */
                    label?: string;
                    /** @description How opaque the whole layer is: 1 is full, 0.01 the least. */
                    value: number;
                };
                /**
                 * @description false makes it a guide layer: laid out and drawn on the author's canvas, never printed or shown to a customer. Absent prints.
                 * @enum {boolean}
                 */
                print?: false;
                props: {
                    /** @description Where the picture sits in its frame, under cover. Absent is uncropped. */
                    crop?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most zoom a customer may choose; absent is 3. */
                            maxZoom?: number;
                            /** @description The least zoom a customer may choose; absent is 1. */
                            minZoom?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: {
                            /** @description How far the picture's centre sits right of the frame's centre, in frame widths: 0.1 is a tenth of the frame. Clamped so the picture always covers the frame, never refused. */
                            xFrac: number;
                            /** @description How far the picture's centre sits below the frame's centre, in frame heights: 0.1 is a tenth of the frame. Clamped so the picture always covers the frame, never refused. */
                            yFrac: number;
                            /** @description The picture's scale over what cover gives it: 1 is the picture just covering the frame, up to 5. */
                            zoom: number;
                        };
                    };
                    /** @description What the silhouette is painted with: a colour, a gradient across its box, or a picture clipped to it. */
                    fill: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description Whether a customer may upload a picture of their own. */
                            allowUpload?: boolean;
                            /**
                             * @description true lets a customer choose any colour, beside or instead of a palette.
                             * @enum {boolean}
                             */
                            anyColor?: true;
                            /**
                             * @description true cuts a customer's upload out onto a transparent background, as a new upload in its place paid from the tenant's credits; one that fails leaves their photo as it was. Absent, never.
                             * @enum {boolean}
                             */
                            cutOut?: true;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                            palette?: string;
                            /** @description Whether a customer must change the template's default (a placeholder name or photo) before a design is accepted. Only on an offered text's content, image's picture, or shape's outline or fill. */
                            requireChange?: boolean;
                            /** @description Whether a customer must choose a picture. */
                            required?: boolean;
                            /** @description Present, an upload below `belowDpi` at the customer's chosen size is offered an upscale to `toDpi` before the proof, paid from the tenant's credits. Absent, never. */
                            upscale?: {
                                /** @description The print resolution, in dots per inch, below which an upload is offered an upscale. Absent, the template's minimum, else the tenant's. */
                                belowDpi?: number;
                                /** @description The print resolution, in dots per inch, an upload is upscaled to, and priced by: under `belowDpi`, at it or past it. Absent, `belowDpi`. */
                                toDpi?: number;
                            };
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: {
                            /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                            cmyk: [
                                number,
                                number,
                                number,
                                number
                            ];
                        } | {
                            /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                            spot: {
                                /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                fallback: {
                                    /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                    cmyk: [
                                        number,
                                        number,
                                        number,
                                        number
                                    ];
                                };
                                /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                name: string;
                                /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                preview?: {
                                    /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                    rgb: [
                                        number,
                                        number,
                                        number
                                    ];
                                };
                            };
                        } | {
                            /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                            ink: string;
                        } | {
                            /** @description An older spelling of an ink reference; send `{ ink }`. */
                            spot: {
                                /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                ink: string;
                            };
                        } | {
                            /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                            entry: string;
                            /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                            palette: string;
                        } | {
                            /** @description linear crosses a shape's box or text's letters at an angle; radial from the centre to the farthest corner. */
                            gradient: {
                                /** @description The direction the colours run, in degrees clockwise from straight up: 90 runs left to right, 180 top to bottom. It spans a shape's box or a text's letters. */
                                angleDeg: number;
                                /** @enum {string} */
                                kind: "linear";
                                /** @description The gradient's colours, 2 to 8, in order of position. Blended in CMYK, as the print blends them. */
                                stops: {
                                    /** @description Where the colour sits along the gradient: 0 is its start, 1 its end. Stops are in order; two at one position make a hard edge. */
                                    at: number;
                                    /** @description The colour at this stop: a CMYK colour, one of your inks, or a palette entry. A spot ink cannot be one: a gradient blends process colours. */
                                    color: {
                                        /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                        cmyk: [
                                            number,
                                            number,
                                            number,
                                            number
                                        ];
                                    } | {
                                        /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                                        spot: {
                                            /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                            fallback: {
                                                /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                                cmyk: [
                                                    number,
                                                    number,
                                                    number,
                                                    number
                                                ];
                                            };
                                            /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                            name: string;
                                            /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                            preview?: {
                                                /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                                rgb: [
                                                    number,
                                                    number,
                                                    number
                                                ];
                                            };
                                        };
                                    } | {
                                        /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                        ink: string;
                                    } | {
                                        /** @description An older spelling of an ink reference; send `{ ink }`. */
                                        spot: {
                                            /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                            ink: string;
                                        };
                                    } | {
                                        /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                                        entry: string;
                                        /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                                        palette: string;
                                    };
                                }[];
                            } | {
                                /** @enum {string} */
                                kind: "radial";
                                /** @description The gradient's colours, 2 to 8, in order of position. Blended in CMYK, as the print blends them. */
                                stops: {
                                    /** @description Where the colour sits along the gradient: 0 is its start, 1 its end. Stops are in order; two at one position make a hard edge. */
                                    at: number;
                                    /** @description The colour at this stop: a CMYK colour, one of your inks, or a palette entry. A spot ink cannot be one: a gradient blends process colours. */
                                    color: {
                                        /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                        cmyk: [
                                            number,
                                            number,
                                            number,
                                            number
                                        ];
                                    } | {
                                        /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                                        spot: {
                                            /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                            fallback: {
                                                /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                                cmyk: [
                                                    number,
                                                    number,
                                                    number,
                                                    number
                                                ];
                                            };
                                            /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                            name: string;
                                            /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                            preview?: {
                                                /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                                rgb: [
                                                    number,
                                                    number,
                                                    number
                                                ];
                                            };
                                        };
                                    } | {
                                        /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                        ink: string;
                                    } | {
                                        /** @description An older spelling of an ink reference; send `{ ink }`. */
                                        spot: {
                                            /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                            ink: string;
                                        };
                                    } | {
                                        /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                                        entry: string;
                                        /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                                        palette: string;
                                    };
                                }[];
                            };
                        } | {
                            /** @description A picture's asset id, clipped to the shape; empty while none is chosen. */
                            imageAssetId: string;
                        };
                    };
                    /** @description How the picture fills its box: cover crops, contain shows it whole, fill stretches, tile repeats it. Absent is cover. */
                    fit?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /**
                         * @description The attribute's value, as the template stores it.
                         * @enum {string}
                         */
                        value: "contain" | "cover" | "fill" | "tile";
                    };
                    /** @description The colour of the line drawn around the layer's edge, outside it; absent is black. */
                    outlineColor?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /**
                             * @description true lets a customer choose any colour, beside or instead of a palette.
                             * @enum {boolean}
                             */
                            anyColor: true;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                            palette: string;
                        } | {
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                            palette?: string;
                        } | {
                            /**
                             * @description true lets a customer choose any colour, beside or instead of a palette.
                             * @enum {boolean}
                             */
                            anyColor: true;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: {
                            /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                            cmyk: [
                                number,
                                number,
                                number,
                                number
                            ];
                        } | {
                            /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                            spot: {
                                /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                fallback: {
                                    /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                    cmyk: [
                                        number,
                                        number,
                                        number,
                                        number
                                    ];
                                };
                                /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                name: string;
                                /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                preview?: {
                                    /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                    rgb: [
                                        number,
                                        number,
                                        number
                                    ];
                                };
                            };
                        } | {
                            /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                            ink: string;
                        } | {
                            /** @description An older spelling of an ink reference; send `{ ink }`. */
                            spot: {
                                /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                ink: string;
                            };
                        } | {
                            /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                            entry: string;
                            /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                            palette: string;
                        };
                    };
                    /** @description The outline's width as a fraction of the shorter side of the layer's box (0.02 is a fiftieth of it), 0 to 0.1; absent or 0 draws no outline. On an image, traced round its box or its picture (effectsFollow); an image sets this or outlineWidthShare, never both. */
                    outlineWidthShortSide?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most value a customer may choose. */
                            max?: number;
                            /** @description The least value a customer may choose. */
                            min?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The step between the values a customer may choose. */
                            step?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: number;
                    };
                    /** @description How soft the shadow is: its blur radius as a fraction of the shorter side of the layer's box, 0 (sharp) to 0.25. A shadow with no offset and no blur draws nothing. */
                    shadowBlurShortSide?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most value a customer may choose. */
                            max?: number;
                            /** @description The least value a customer may choose. */
                            min?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The step between the values a customer may choose. */
                            step?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: number;
                    };
                    /** @description The colour of the shadow drawn under the layer; absent is black. */
                    shadowColor?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /**
                             * @description true lets a customer choose any colour, beside or instead of a palette.
                             * @enum {boolean}
                             */
                            anyColor: true;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                            palette: string;
                        } | {
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The palette a customer picks from: one of your palettes' ids (`pal_…`) in a template you write; its name, with the palette under `palettes`, in a published template as served. */
                            palette?: string;
                        } | {
                            /**
                             * @description true lets a customer choose any colour, beside or instead of a palette.
                             * @enum {boolean}
                             */
                            anyColor: true;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: {
                            /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                            cmyk: [
                                number,
                                number,
                                number,
                                number
                            ];
                        } | {
                            /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                            spot: {
                                /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                                fallback: {
                                    /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                    cmyk: [
                                        number,
                                        number,
                                        number,
                                        number
                                    ];
                                };
                                /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                                name: string;
                                /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                                preview?: {
                                    /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                    rgb: [
                                        number,
                                        number,
                                        number
                                    ];
                                };
                            };
                        } | {
                            /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                            ink: string;
                        } | {
                            /** @description An older spelling of an ink reference; send `{ ink }`. */
                            spot: {
                                /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                                ink: string;
                            };
                        } | {
                            /** @description The linked entry's id within that palette, `pe_…`, as get_palette returns it. The colour follows the entry. */
                            entry: string;
                            /** @description The linked palette's id, `pal_…`, as list_palettes returns it. */
                            palette: string;
                        };
                    };
                    /** @description How far right the shadow falls, as a fraction of the shorter side of the layer's box, -0.25 to 0.25; negative is left. */
                    shadowOffsetXShortSide?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most value a customer may choose. */
                            max?: number;
                            /** @description The least value a customer may choose. */
                            min?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The step between the values a customer may choose. */
                            step?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: number;
                    };
                    /** @description How far down the shadow falls, as a fraction of the shorter side of the layer's box, -0.25 to 0.25; negative is up. */
                    shadowOffsetYShortSide?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The most value a customer may choose. */
                            max?: number;
                            /** @description The least value a customer may choose. */
                            min?: number;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description The step between the values a customer may choose. */
                            step?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: number;
                    };
                    /** @description The layer's silhouette: inline geometry or one of the tenant's shapes. */
                    shape: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /**
                             * @description true lets a customer choose no shape at all.
                             * @enum {boolean}
                             */
                            allowEmpty?: true;
                            /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                            oneOf?: string[];
                            /** @description Whether a customer must change the template's default (a placeholder name or photo) before a design is accepted. Only on an offered text's content, image's picture, or shape's outline or fill. */
                            requireChange?: boolean;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: {
                            /** @description SVG path data in fractions of its box, (0,0) its top-left and (1,1) its bottom-right: `M 0 0 L 1 0 L 1 1 L 0 1 Z` is the whole box. No arcs. */
                            dFrac: string;
                            /**
                             * @description Inline path geometry.
                             * @enum {string}
                             */
                            type: "path";
                        } | {
                            /** @description The shape's id, `shp_…`, as list_shapes returns it. */
                            shapeId: string;
                            /**
                             * @description One of the tenant's shapes, by id.
                             * @enum {string}
                             */
                            type: "shape";
                        };
                    };
                    /** @description The tile's size against the picture's own, when the fit is tile. */
                    tileScale?: {
                        /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                        constraints?: {
                            /** @description The largest tile scale a customer may choose. */
                            max?: number;
                            /** @description The smallest tile scale a customer may choose. */
                            min?: number;
                            /** @description The step between the tile scales a customer may choose. */
                            step?: number;
                        };
                        /** @description A hint shown to the customer under the attribute's field. */
                        description?: string;
                        /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                        editable: boolean;
                        /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                        fieldKey?: string;
                        /** @description What a customer reads the attribute as, when editable. */
                        label?: string;
                        /** @description The attribute's value, as the template stores it. */
                        value: number;
                    };
                };
                /** @description The layer's rotation, scale and flip, and which of them, and its position, a customer may change. */
                transform: {
                    /** @description Whether a customer may flip the layer. */
                    flip?: {
                        /** @description A hint shown to the customer under the control. */
                        description?: string;
                        /** @description Whether a customer may change it. */
                        editable: boolean;
                        /** @description What a customer reads the control as. */
                        label?: string;
                    };
                    /** @description Whether, and within what, a customer may resize the layer. */
                    resize?: {
                        /** @description A hint shown to the customer under the control. */
                        description?: string;
                        /** @description Whether a customer may change it. */
                        editable?: boolean;
                        /** @description What a customer reads the control as. */
                        label?: string;
                        /** @description The most height, in millimetres. */
                        maxHMm?: number;
                        /** @description The most width, in millimetres. */
                        maxWMm?: number;
                        /** @description The least height, in millimetres. */
                        minHMm?: number;
                        /** @description The least width, in millimetres. */
                        minWMm?: number;
                    };
                    /** @description Whether, and how far, a customer may rotate the layer. */
                    rotate: {
                        /** @description A hint shown to the customer under the control. */
                        description?: string;
                        /** @description Whether a customer may change it. */
                        editable: boolean;
                        /** @description What a customer reads the control as. */
                        label?: string;
                        /** @description The most rotation, in degrees. */
                        max?: number;
                        /** @description The least rotation, in degrees. */
                        min?: number;
                        /** @description The angle rotation snaps to, in degrees, e.g. 15. */
                        snapDeg?: number;
                    };
                    /** @description Whether, and how far, a customer may scale the layer. */
                    scale: {
                        /** @description A hint shown to the customer under the control. */
                        description?: string;
                        /** @description Whether a customer may change it. */
                        editable: boolean;
                        /** @description What a customer reads the control as. */
                        label?: string;
                        /** @description The most scale; 1 is as authored. */
                        max?: number;
                        /** @description The least scale; 1 is as authored. */
                        min?: number;
                        /** @description The step between the scales a customer may choose. */
                        step?: number;
                    };
                    /** @description Whether, and within what, a customer may move the layer. */
                    translate: {
                        /**
                         * @description Where a customer's move must keep the layer: inside the safe area (the default), the print box, or anywhere.
                         * @enum {string}
                         */
                        bounds?: "safeArea" | "printBox" | "none";
                        /** @description A hint shown to the customer under the control. */
                        description?: string;
                        /** @description Whether a customer may change it. */
                        editable: boolean;
                        /** @description What a customer reads the control as. */
                        label?: string;
                        /** @description What a move snaps to: centre, thirds, safeEdges, layers. */
                        snapTo?: ("centre" | "thirds" | "safeEdges" | "layers")[];
                    };
                    /** @description The layer's rotation, scale and flip. */
                    value: {
                        /** @description Whether the layer is mirrored left to right, about its centre and before its rotation. */
                        flipX?: boolean;
                        /** @description Whether the layer is mirrored top to bottom, about its centre and before its rotation. */
                        flipY?: boolean;
                        /** @description Rotation about the layer's anchor, in degrees, clockwise. */
                        rotationDeg: number;
                        /** @description Scale of the layer; 1 is as authored. */
                        scale: number;
                    };
                };
                /** @enum {string} */
                type: "shape";
                /**
                 * @description true lays spot varnish exactly where the layer is, on a machine that varnishes; it still prints in colour.
                 * @enum {boolean}
                 */
                varnish?: true;
                /** @description The layer's width as a fraction of the reference's width. Positive; uncapped, so above 1 hangs over the edge and is clipped. */
                wFrac: number;
                /** @description Paint depth, lowest painted first. A multiple of 10 follows the layer's place in the list; any other value pins it. */
                z: number;
            })[];
            /** @description The template as it reads in other languages: for each customer-facing language, what differs from the original, by layer and group id. A reader naming a language gets the original with that language's overrides merged in; what a language does not override reads as the original. A language cannot add or remove layers, and a customer's own values are never overridden. */
            localized?: {
                [key: string]: {
                    /** @description Its groups' labels in this language, by group id. */
                    groups?: {
                        [key: string]: {
                            label: string;
                        };
                    };
                    /** @description Its layers as they read in this language, by layer id. */
                    layers?: {
                        [key: string]: {
                            /**
                             * @description The point of the reference the layer is placed against, and the layer's own matching point: top-left puts the layer's top-left corner on the reference's.
                             * @enum {string}
                             */
                            anchor?: "top-left" | "top-center" | "top-right" | "center-left" | "center" | "center-right" | "bottom-left" | "bottom-center" | "bottom-right";
                            /** @description Another layer's id, to place and size this one against that layer's box instead of the plate. A missing layer falls back to the plate. */
                            anchorTo?: string;
                            /** @description The layer's height as a fraction of the reference's height. Positive; uncapped, so above 1 hangs over the edge and is clipped. */
                            hFrac?: number;
                            /** @description The layer's mat in this language. */
                            mat?: unknown;
                            /** @description What the author reads the layer as. Not unique; absent, the layer reads as its id. */
                            name?: string;
                            /** @description How far the layer sits from its anchor, as fractions of the reference, always toward the reference's centre: { x: 0.05, y: 0.05 } nudges it 5 % in from any corner. Ignored on a centred axis. */
                            offsetFrac?: {
                                /** @description Across, as a fraction of the reference's width: 0.05 is 5 %. Toward the centre; negative pushes outward. Uncapped. */
                                x: number;
                                /** @description Down or up, as a fraction of the reference's height: 0.05 is 5 %. Toward the centre; negative pushes outward. Uncapped. */
                                y: number;
                            };
                            /** @description A prop as it reads in this language: any of its value, label, description and constraints. Whether a customer may change it, and its field key, stay the original's. */
                            opacity?: {
                                constraints?: unknown;
                                description?: unknown;
                                label?: string;
                                value?: unknown;
                            };
                            /**
                             * @description false makes it a guide layer: laid out and drawn on the author's canvas, never printed or shown to a customer. Absent prints.
                             * @enum {boolean}
                             */
                            print?: false;
                            /** @description Its props as they read in this language, by name. */
                            props?: {
                                [key: string]: {
                                    constraints?: unknown;
                                    description?: unknown;
                                    label?: string;
                                    value?: unknown;
                                };
                            };
                            /** @description The text layer's text box in this language. */
                            textBox?: unknown;
                            /** @description The layer's transform in this language: its rotation, scale and flip, and for each axis its bounds, limits and words. Whether a customer may change an axis stays the original's. */
                            transform?: {
                                /** @description The words of the layer's flip control, in this language. */
                                flip?: {
                                    /** @description A hint shown to the customer under the control. */
                                    description?: string;
                                    /** @description What a customer reads the control as. */
                                    label?: string;
                                };
                                /** @description Within what a customer may resize the layer, in this language. */
                                resize?: {
                                    /** @description A hint shown to the customer under the control. */
                                    description?: string;
                                    /** @description What a customer reads the control as. */
                                    label?: string;
                                    /** @description The most height, in millimetres. */
                                    maxHMm?: number;
                                    /** @description The most width, in millimetres. */
                                    maxWMm?: number;
                                    /** @description The least height, in millimetres. */
                                    minHMm?: number;
                                    /** @description The least width, in millimetres. */
                                    minWMm?: number;
                                };
                                /** @description How far a customer may rotate the layer, in this language. */
                                rotate?: {
                                    /** @description A hint shown to the customer under the control. */
                                    description?: string;
                                    /** @description What a customer reads the control as. */
                                    label?: string;
                                    /** @description The most rotation, in degrees. */
                                    max?: number;
                                    /** @description The least rotation, in degrees. */
                                    min?: number;
                                    /** @description The angle rotation snaps to, in degrees, e.g. 15. */
                                    snapDeg?: number;
                                };
                                /** @description How far a customer may scale the layer, in this language. */
                                scale?: {
                                    /** @description A hint shown to the customer under the control. */
                                    description?: string;
                                    /** @description What a customer reads the control as. */
                                    label?: string;
                                    /** @description The most scale; 1 is as authored. */
                                    max?: number;
                                    /** @description The least scale; 1 is as authored. */
                                    min?: number;
                                    /** @description The step between the scales a customer may choose. */
                                    step?: number;
                                };
                                /** @description Within what a customer may move the layer, in this language. */
                                translate?: {
                                    /**
                                     * @description Where a customer's move must keep the layer: inside the safe area (the default), the print box, or anywhere.
                                     * @enum {string}
                                     */
                                    bounds?: "safeArea" | "printBox" | "none";
                                    /** @description A hint shown to the customer under the control. */
                                    description?: string;
                                    /** @description What a customer reads the control as. */
                                    label?: string;
                                    /** @description What a move snaps to: centre, thirds, safeEdges, layers. */
                                    snapTo?: ("centre" | "thirds" | "safeEdges" | "layers")[];
                                };
                                /** @description The layer's rotation, scale and flip. */
                                value?: {
                                    /** @description Whether the layer is mirrored left to right, about its centre and before its rotation. */
                                    flipX?: boolean;
                                    /** @description Whether the layer is mirrored top to bottom, about its centre and before its rotation. */
                                    flipY?: boolean;
                                    /** @description Rotation about the layer's anchor, in degrees, clockwise. */
                                    rotationDeg: number;
                                    /** @description Scale of the layer; 1 is as authored. */
                                    scale: number;
                                };
                            };
                            /**
                             * @description true lays spot varnish exactly where the layer is, on a machine that varnishes; it still prints in colour.
                             * @enum {boolean}
                             */
                            varnish?: true;
                            /** @description The layer's width as a fraction of the reference's width. Positive; uncapped, so above 1 hangs over the edge and is clipped. */
                            wFrac?: number;
                            /** @description Paint depth, lowest painted first. A multiple of 10 follows the layer's place in the list; any other value pins it. */
                            z?: number;
                        };
                    };
                };
            };
            name: string;
            /** @description Colours the template offers as its own, by name: a palette offer names one by that name. A stored template holds one only where a library palette it offered was deleted; a published template as served holds every palette it offers. */
            palettes?: {
                [key: string]: {
                    /** @description The colour. */
                    color: {
                        /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                        cmyk: [
                            number,
                            number,
                            number,
                            number
                        ];
                    } | {
                        /** @description A spot (named) ink colour with the CMYK that prints in its place. */
                        spot: {
                            /** @description The CMYK that prints and separates in place of the spot ink; it is what reaches the plate. */
                            fallback: {
                                /** @description A CMYK colour: cyan, magenta, yellow and black in that order, each a percentage of ink from 0 to 100, e.g. [0, 100, 100, 0] for a red. */
                                cmyk: [
                                    number,
                                    number,
                                    number,
                                    number
                                ];
                            };
                            /** @description The spot colour's name as the print shop knows it, e.g. a Pantone name. */
                            name: string;
                            /** @description How a screen paints the spot, as an RGB colour. Never what prints. */
                            preview?: {
                                /** @description An RGB colour: red, green and blue in that order, each on the 0 to 255 scale, e.g. [255, 0, 0] for red. */
                                rgb: [
                                    number,
                                    number,
                                    number
                                ];
                            };
                        };
                    } | {
                        /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                        ink: string;
                    } | {
                        /** @description An older spelling of an ink reference; send `{ ink }`. */
                        spot: {
                            /** @description One of the tenant's inks, by its id, as the ink library lists it. */
                            ink: string;
                        };
                    };
                    /** @description The name a customer picks the colour by. */
                    name: string;
                }[];
            };
            /** @description The artwork's aspect ratio as two positive numbers ({ w: 3, h: 2 } is landscape): the shape of the plate every fraction is of. */
            ratio: {
                /** @description The ratio's height part. Positive. */
                h: number;
                /** @description The ratio's width part. Positive. */
                w: number;
            };
            /** @description How far, as a fraction of the ratio, a print size may differ from it: 0.02 is 2 %. 0 or more. */
            ratioTolerance: number;
            /** @description The die-cut outline the print is cut to, which a customer may be offered. Absent is a square-cornered rectangle. */
            shape?: {
                /** @description What a customer may choose, when editable. Absent, the attribute's own range. */
                constraints?: {
                    /**
                     * @description true lets a customer choose no shape at all.
                     * @enum {boolean}
                     */
                    allowEmpty?: true;
                    /** @description The values a customer may choose from, when the attribute is editable: font families, picture asset ids, shape ids (`shp_…`) or fits. Absent, any value the attribute takes. */
                    oneOf?: string[];
                    /** @description Whether a customer must change the template's default (a placeholder name or photo) before a design is accepted. Only on an offered text's content, image's picture, or shape's outline or fill. */
                    requireChange?: boolean;
                };
                /** @description A hint shown to the customer under the attribute's field. */
                description?: string;
                /** @description Whether a customer may change it. A layer is customer-editable when any of its attributes is. */
                editable: boolean;
                /** @description The author's word for the field (`name`, `photo`), unique within the template. A customer's value for a keyed field follows them to any template with a field of the same key. */
                fieldKey?: string;
                /** @description What a customer reads the attribute as, when editable. */
                label?: string;
                /** @description The attribute's value, as the template stores it. */
                value: {
                    /** @description SVG path data in fractions of its box, (0,0) its top-left and (1,1) its bottom-right: `M 0 0 L 1 0 L 1 1 L 0 1 Z` is the whole box. No arcs. */
                    dFrac: string;
                    /**
                     * @description Inline path geometry.
                     * @enum {string}
                     */
                    type: "path";
                } | {
                    /** @description The shape's id, `shp_…`, as list_shapes returns it. */
                    shapeId: string;
                    /**
                     * @description One of the tenant's shapes, by id.
                     * @enum {string}
                     */
                    type: "shape";
                };
            };
            /** @description What a customer's moves snap to, and the author's grid. */
            snap?: {
                /** @description The author's grid, which the author's drags snap to. A customer never sees it. */
                grid?: {
                    /** @description The grid's step as a fraction of the plate, 0.01 to 0.5: 0.05 is a line every 5 %. */
                    stepFrac: number;
                };
                /** @description What a move snaps to: centre, thirds, safeEdges, layers. */
                targets?: ("centre" | "thirds" | "safeEdges" | "layers")[];
            };
            tenantId?: string;
            uploads?: {
                /** @description The file formats a customer may upload, each once: png, jpeg, webp, heic. Absent, all of them. */
                formats?: ("png" | "jpeg" | "webp" | "heic")[];
                /** @description The largest upload, in bytes, at most 83886080. Absent, that. */
                maxBytes?: number;
                /** @description The minimum print resolution a design's pictures are judged against where they print, in dots per inch, at most 1200. Absent, the tenant's. */
                minDpi?: number;
            };
            version: number;
        };
        TemplateLiveChangedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                baseId: string;
                live: boolean;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "template.live_changed";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        TemplatePublishedEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                templateId: string;
                version: number;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "template.published";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
        TextMessagesLowEvent: {
            /** @description The automation that caused the event, beside `via`. */
            automation?: {
                /** @description The automation's id. */
                id: string;
                /** @description What the automation was called when it acted. */
                name: string;
            };
            /** @description When the event happened, in milliseconds since the Unix epoch. */
            createdAt: number;
            /** @description The event's id. A retry or a redelivery carries the same id, so a receiver can drop one it has already handled. */
            id: string;
            payload: {
                allowanceTexts: number;
                monthStart: number;
                usedTexts: number;
            };
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: "text_messages.low";
            /**
             * @description `automation` when one of your automations caused the event; absent otherwise.
             * @enum {string}
             */
            via?: "automation";
        };
    };
    responses: never;
    parameters: never;
    requestBodies: never;
    headers: {
        /** @description Every response names the request it answers in `X-Request-Id`: the id the request was sent with in that header, when it is well formed, else one the API gave it. Quote it when reporting a refusal or a failure: the API's log lines for that request carry it. */
        RequestId: string;
    };
    pathItems: never;
}
export type $defs = Record<string, never>;
export interface operations {
    "prints.artwork.get": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                token: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The print file: its PDF, or the raster its machine takes */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/pdf": string;
                    "image/png": string;
                    "image/tiff": string;
                };
            };
            /** @description Refused: plan_limit_reached, order_balance_empty, forbidden */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The limit the tenant is at: `templates`, `connectedStores`, `apiKeys`, `shareLinks`, `customDomains`, `printsMadePerMonth` (prints made without an order this month), `members`, `orders` (this month's orders, which getting a print's files without an order counts as), or a sandbox's own caps: `sandboxPrintsPerDay`, `sandboxPrintsPerMonth`, `sandboxOrdersPerMonth`. A sandbox shares every other limit with its live workspace. Always sent with `plan_limit_reached`. */
                        limit?: string;
                        /** @description How many the plan allows. Always sent with `plan_limit_reached`. */
                        max?: number;
                        /** @description The plan whose limit it is. Always sent with `plan_limit_reached`. */
                        plan?: string;
                    };
                };
            };
            /** @description The token does not verify or has expired, or the print has no artwork */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description The order's machine lays a white or a varnish this print cannot be handed out with, or takes a raster this print is too large for */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description The request failed unexpectedly. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "prints.deliveryFile.get": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                token: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The print file, or its job ticket */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        [key: string]: unknown;
                    };
                    "application/pdf": string;
                    "image/png": string;
                    "image/tiff": string;
                };
            };
            /** @description The token does not verify or has expired, or the print has no such part */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description The order's machine lays a white or a varnish this print cannot be handed out with */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description The request failed unexpectedly. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "fonts.files.get": {
        parameters: {
            query?: {
                text?: string;
            };
            header?: never;
            path: {
                file: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The font file */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "font/ttf": string;
                    "font/woff2": string;
                };
            };
            /** @description Not modified: the `If-None-Match` etag still holds */
            304: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description No font file by that name: `<sha256>.ttf` or `<sha256>.woff2` naming a hash the catalog has made (plain text) */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description The request failed unexpectedly. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "catalogueImages.get": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                token: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The file's bytes */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    /** @description The uploaded file's height in pixels, when it is known. The bytes served may be a smaller preview. */
                    "x-pixonaut-original-height"?: number;
                    /** @description The uploaded file's width in pixels, when it is known. The bytes served may be a smaller preview. */
                    "x-pixonaut-original-width"?: number;
                    [name: string]: unknown;
                };
                content: {
                    "image/heic": string;
                    "image/heif": string;
                    "image/jpeg": string;
                    "image/png": string;
                    "image/webp": string;
                };
            };
            /** @description The caller's copy, named by its ETag, is current */
            304: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description The token does not verify or has expired, or the image it names is gone (plain text), or `showcase_not_found`: the template holds no showcase with the id `showcase` names */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": string;
                };
            };
            /** @description Refused: asset_map_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Always sent with `asset_map_too_large`. */
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `asset_map_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description The caller left before the render started */
            499: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: template_defaults_invalid. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
            /** @description Refused: print_box_unavailable, assets_unavailable, preview_unavailable */
            503: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
        };
    };
    "logos.get": {
        parameters: {
            query?: {
                /** @description The width in pixels the image is drawn at. The long edge served is derived from the image's own ratio, never larger than the stored image, and clamped to the sizes the api serves. */
                width?: string;
                /** @description `cover` when the image is cropped to fill its box: `width` is then its short edge. */
                fit?: "cover";
            };
            header?: never;
            path: {
                token: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The file's bytes */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    /** @description The uploaded file's height in pixels, when it is known. The bytes served may be a smaller preview. */
                    "x-pixonaut-original-height"?: number;
                    /** @description The uploaded file's width in pixels, when it is known. The bytes served may be a smaller preview. */
                    "x-pixonaut-original-width"?: number;
                    [name: string]: unknown;
                };
                content: {
                    "image/heic": string;
                    "image/heif": string;
                    "image/jpeg": string;
                    "image/png": string;
                    "image/webp": string;
                };
            };
            /** @description Not modified: the `If-None-Match` etag still holds */
            304: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description The token does not verify or has expired, or the image is no longer the tenant's logo (plain text) */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Refused: invalid_query */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description The request failed unexpectedly. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "assets.published.get": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The file's bytes */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    /** @description The uploaded file's height in pixels, when it is known. The bytes served may be a smaller preview. */
                    "x-pixonaut-original-height"?: number;
                    /** @description The uploaded file's width in pixels, when it is known. The bytes served may be a smaller preview. */
                    "x-pixonaut-original-width"?: number;
                    [name: string]: unknown;
                };
                content: {
                    "image/heic": string;
                    "image/heif": string;
                    "image/jpeg": string;
                    "image/png": string;
                    "image/webp": string;
                };
            };
            /** @description Not modified: the `If-None-Match` etag still holds */
            304: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description No such public library asset (plain text) */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description The request failed unexpectedly. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "proofs.image.get": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                token: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The proof image */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "image/jpeg": string;
                };
            };
            /** @description The token does not verify, has expired or is not a proof link, or the image is gone */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description The request failed unexpectedly. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "templates.mockup.get": {
        parameters: {
            query: {
                /** @description The blank whose placement the mockup is of. */
                blankId: string;
                /** @description The placement on that blank. */
                placementId: string;
                /** @description One of the placement's mockup photos. Name it or `viewId`, not both; neither draws on the placement's first view. */
                mockupId?: string;
                /** @description One of the placement's views: the render uses its photo of `variant`, else its default photo. Name it or `mockupId`, not both. */
                viewId?: string;
                /** @description A variant ref of the blank, with `viewId`: the render uses the view's photo that shows it. */
                variant?: string;
                /** @description The long edge in pixels, clamped to the sizes the api renders. */
                size?: string;
                /** @description Refused: a full-bleed reference cannot be composited. */
                bleed?: string;
                /** @description The id of one of the template's showcases, as its read lists them: the template is drawn with that set's values in place of its defaults. */
                showcase?: string;
            };
            header?: never;
            path: {
                /** @description A published template id, `baseId@version`. */
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The template on the product photo */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "image/png": string;
                };
            };
            /** @description The caller's copy, named by its ETag, is current */
            304: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Refused: bleed_not_compositable */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, feature_disabled, forbidden, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description No published template, blank, placement or mockup answers to these ids, or `showcase_not_found`: the template holds no showcase with the id `showcase` names */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": string;
                };
            };
            /** @description Refused: mockup_rect_unusable, mockup_rect_outside_photo, mockup_placed_box_empty, photo_decode_failed, mockup_mesh_unusable, mockup_cut_unusable, mockup_mask_decode_failed, mockup_uv_decode_failed, mockup_uv_pass_mismatch, unknown_variant, variant_retired, variant_has_no_photo, mockup_mask_unreadable, mockup_uv_unreadable, asset_map_too_large, invalid_query */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Always sent with `asset_map_too_large`. */
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `asset_map_too_large`. */
                        maxBytes?: number;
                        /** @description Always sent with `unknown_variant`, `variant_retired`, `variant_has_no_photo`. */
                        reason?: string;
                        /** @description Always sent with `unknown_variant`. */
                        ref?: string;
                        /** @description With `variant_retired`: The retired variant's ref. With `variant_has_no_photo`: The variant's ref. Always sent with `variant_retired`, `variant_has_no_photo`. */
                        variant?: string;
                        /** @description The view's label. Always sent with `variant_has_no_photo`. */
                        view?: string;
                        /** @description Always sent with `variant_has_no_photo`. */
                        viewId?: string;
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description The caller left before the render started */
            499: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: artwork_decode_failed, encode_failed, downscale_size_overflow, input_too_large, mockup_warp_unreadable, mockup_mesh_unreadable, mockup_cut_unreadable, mockup_uv_view_missing, composite_failed, template_defaults_invalid, db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
            /** @description Refused: print_box_unavailable, asset_store_unavailable, assets_unavailable */
            503: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
        };
    };
    "templates.preview.get": {
        parameters: {
            query?: {
                /** @description The long edge in pixels, clamped to the sizes the api renders. */
                size?: string;
                /** @description The width in pixels the image is drawn at, for a caller that does not know its ratio: the long edge is derived from the template's declared ratio, and clamped as `size` is. Taken over `size` when both are given. */
                width?: string;
                /** @description `cover` when the image is cropped to fill its box: `width` is then its short edge. */
                fit?: "cover";
                /** @description `1` for the unclipped full-bleed reference. */
                bleed?: string;
                /** @description The id of one of the template's showcases, as its read lists them: the image is drawn with that set's values in place of the defaults. */
                showcase?: string;
            };
            header?: never;
            path: {
                /** @description A template id, `baseId@version`. */
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The preview image */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "image/png": string;
                };
            };
            /** @description The caller's copy, named by its ETag, is current */
            304: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, feature_disabled, forbidden, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description No published template has this id, or `showcase_not_found`: the template holds no showcase with the id `showcase` names */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": string;
                };
            };
            /** @description Refused: draft_invalid, template_defaults_invalid, draft_has_no_artwork, asset_map_too_large, invalid_query */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Always sent with `asset_map_too_large`. */
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `asset_map_too_large`. */
                        maxBytes?: number;
                        /** @description Always sent with `draft_invalid`. */
                        reason?: string;
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description The caller left before the render started */
            499: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: template_defaults_invalid, db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
            /** @description Refused: print_box_unavailable, assets_unavailable, preview_unavailable */
            503: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
        };
    };
    "assets.upload": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                token: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The file is stored */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        assetId: string;
                        /** @description The asset's `contentKey`, as its listing reports it: pass it as `v` to `/v1/assets/{id}/content` and the answer is cached `immutable`. */
                        contentKey: string;
                        effectiveDpi: number | null;
                        heightPx: number;
                        /** @description Set when this upload is below the minimum print resolution at its size and may be improved before the proof (`POST /v1/assets/{id}/improve-resolution`), to this size: the template allows upscaling, the tenant's plan and credits cover it, and the shortfall is within one upscale. Null otherwise. */
                        improveResolution: {
                            heightPx: number;
                            widthPx: number;
                        } | null;
                        warning: string | null;
                        warningKey: string | null;
                        warningParams: {
                            actualPx: number;
                            minPx?: number;
                        } | {
                            storedBytes: number;
                            uploadBytes: number;
                        } | null;
                        widthPx: number;
                    };
                };
            };
            /** @description Refused: unknown_upload */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: upload_expired */
            410: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: size_mismatch, unsupported_mime, animation_not_supported, not_a_valid_image, pixel_dimensions_too_large, size_out_of_bounds */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Always sent with `unsupported_mime`. */
                        allowed?: string[];
                        error: string;
                        /** @description Always sent with `pixel_dimensions_too_large`, `pixel_dimensions_too_large`. */
                        heightPx?: number;
                        /** @description Always sent with `size_out_of_bounds`. */
                        maxBytes?: number;
                        /** @description Always sent with `pixel_dimensions_too_large`. */
                        maxEdgePx?: number;
                        /** @description Always sent with `pixel_dimensions_too_large`. */
                        maxPixels?: number;
                        /** @description Always sent with `pixel_dimensions_too_large`, `pixel_dimensions_too_large`. */
                        widthPx?: number;
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: preview_failed. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
            /** @description Refused: lock_timeout */
            503: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: storage_quota_exceeded. The tenant's storage quota would be exceeded. `usedBytes` and `quotaBytes` are left out for a publishable key. */
            507: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `storage_quota_exceeded`. */
                        quotaBytes?: number;
                        /** @description Always sent with `storage_quota_exceeded`. */
                        usedBytes?: number;
                    };
                };
            };
        };
    };
    "customerSessions.get": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The session's assets and proofs */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        assets: {
                            created_at: number;
                            id: string;
                            layer_id: string | null;
                            mime: string;
                            retained: number;
                            size_bytes: number;
                            template_id: string | null;
                        }[];
                        proofs: {
                            created_at: number;
                            doc_hash: string;
                            expires_at: number;
                            id: string;
                            retained: number;
                            template_id: string;
                        }[];
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, secret_key_required, feature_disabled */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "apiKeys.list": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The keys */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        allowedOrigins: string[];
                        /** @description The connected store the key was given to; null for a key minted on its own. Such a key is revoked by disconnecting the store. */
                        connectionId: string | null;
                        createdAt: number;
                        /** @description The member who created the key; null for one a secret key created. */
                        createdBy: {
                            name: string | null;
                            userId: string;
                        } | null;
                        /** @description When an MCP key stops working; null for a key that never does. */
                        expiresAt: number | null;
                        id: string;
                        kind: string;
                        label: string;
                        /** @description A key from the deployment's configuration: listed, never revocable here. */
                        managed: boolean;
                        /** @description The feature the key works only while the tenant has: `api` for a secret key and a publishable key for origins beyond the tenant's own site, `mcp` for an MCP key; null for a connected store's integration key and a publishable key bound to the tenant's own site. */
                        needsFeature: string | null;
                    }[];
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, feature_disabled */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "apiKeys.create": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    allowedOrigins?: string[];
                    /** @description An MCP key's lifetime in days; 30 when absent. Refused for any other kind, which never expires. */
                    expiresInDays?: 7 | 30 | 90 | 365;
                    /** @enum {string} */
                    kind: "pk" | "sk" | "mcp";
                    label?: string;
                };
            };
        };
        responses: {
            /** @description The new key */
            201: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        allowedOrigins: string[];
                        createdAt: number;
                        expiresAt: number | null;
                        id: string;
                        /** @description The key itself. Shown in this response only. */
                        key: string;
                        kind: string;
                        label: string;
                        /** @description Where an AI assistant reaches Pixel's tools with an MCP key: this API's own MCP address. Null for any other kind. */
                        mcpServer: string | null;
                    };
                };
            };
            /** @description Refused: invalid_origin, origins_not_allowed, expiry_not_allowed, invalid_input */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `invalid_origin`. */
                        origin?: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: forbidden, feature_disabled, plan_limit_reached, origin_forbidden */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                        /** @description The limit the tenant is at: `templates`, `connectedStores`, `apiKeys`, `shareLinks`, `customDomains`, `printsMadePerMonth` (prints made without an order this month), `members`, `orders` (this month's orders, which getting a print's files without an order counts as), or a sandbox's own caps: `sandboxPrintsPerDay`, `sandboxPrintsPerMonth`, `sandboxOrdersPerMonth`. A sandbox shares every other limit with its live workspace. Always sent with `plan_limit_reached`. */
                        limit?: string;
                        /** @description How many the plan allows. Always sent with `plan_limit_reached`. */
                        max?: number;
                        /** @description The plan whose limit it is. Always sent with `plan_limit_reached`. */
                        plan?: string;
                    };
                };
            };
            /** @description Refused: payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
            /** @description Refused: lock_timeout */
            503: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
        };
    };
    "apiKeys.delete": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The key was revoked */
            204: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, feature_disabled */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: config_managed, connection_key */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "apiKeys.update": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description A publishable key's origins, replacing the ones it has. Refused for any other kind. */
                    allowedOrigins?: string[];
                    /** @description The key's new name. */
                    label?: string;
                };
            };
        };
        responses: {
            /** @description The key, changed */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        allowedOrigins: string[];
                        id: string;
                        kind: string;
                        label: string;
                    };
                };
            };
            /** @description Refused: invalid_origin, origins_not_allowed, invalid_input */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `invalid_origin`. */
                        origin?: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: forbidden, feature_disabled, origin_forbidden */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: config_managed, connection_key */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "assetCategories.list": {
        parameters: {
            query?: {
                /** @description The page to read, from 1; the first when left out. */
                page?: number;
                pageSize?: number;
                /** @description Only the rows whose name holds this text, case aside. Naming `q`, `page` or `pageSize` answers a page with the total that match; naming none answers every row. */
                q?: string;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description A page of the categories, or every category */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        categories: {
                            assetCount: number;
                            id: string;
                            name: string;
                        }[];
                        page: number;
                        pageSize: number;
                        total: number;
                    } | {
                        assetCount: number;
                        id: string;
                        name: string;
                    }[];
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: invalid_query */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "assetCategories.create": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description The category's name, 1 to 200 characters, e.g. `Logos`. */
                    name: string;
                };
            };
        };
        responses: {
            /** @description The category was created */
            201: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        id: string;
                        name: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: duplicate_category */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: payload_too_large, invalid_name */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Sent with `payload_too_large`. */
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "assetCategories.delete": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The category was deleted */
            204: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "assetCategories.update": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description The category's name, 1 to 200 characters, e.g. `Logos`. */
                    name: string;
                };
            };
        };
        responses: {
            /** @description The category was renamed */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        id: string;
                        name: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: duplicate_category */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: payload_too_large, invalid_name */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Sent with `payload_too_large`. */
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "assets.checkDuplicate": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                sha256hex: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Whether the bytes are stored, and as which asset (the earliest) */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @enum {boolean} */
                        exists: false;
                    } | {
                        assetId: string;
                        /** @enum {boolean} */
                        exists: true;
                        name: string | null;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: invalid_hash */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "assetFilters.list": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The filter values */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        categories: {
                            id: string;
                            name: string;
                        }[];
                        sessions: string[];
                        tags: string[];
                        templates: string[];
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "assetTags.list": {
        parameters: {
            query?: {
                /** @description The page to read, from 1; the first when left out. */
                page?: number;
                pageSize?: number;
                /** @description Only the rows whose name holds this text, case aside. Naming `q`, `page` or `pageSize` answers a page with the total that match; naming none answers every row. */
                q?: string;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description A page of the tags, or every tag */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        page: number;
                        pageSize: number;
                        tags: {
                            assetCount: number;
                            tag: string;
                        }[];
                        total: number;
                    } | {
                        assetCount: number;
                        tag: string;
                    }[];
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: invalid_query */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "assets.list": {
        parameters: {
            query?: {
                kind?: "library" | "design-upload";
                role?: "picture" | "blank-photo";
                category?: string;
                tag?: string;
                q?: string;
                retention?: "retained" | "auto-delete";
                session?: string;
                template?: string;
                sort?: "most-used";
                ids?: string;
                upscaleSources?: "show" | "hide";
                page?: number;
                pageSize?: number;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description A page of assets */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        assets: {
                            categoryId: string | null;
                            /** @description The stored picture's colour model: `cmyk` for a CMYK JPEG, kept as uploaded. Null until it was read. */
                            colourModel: string | null;
                            /** @description The description of the colour profile the picture embeds, such as `sRGB IEC61966-2.1`. Null when it embeds none. */
                            colourProfile: string | null;
                            /** @description Names the asset's stored bytes, which never change. Pass it as `v` to `/v1/assets/{id}/content` and the answer is cached `immutable`. */
                            contentKey: string | null;
                            createdAt: number;
                            expiresAt: number;
                            /** @description Whether any pixel of the picture is not fully opaque. Null until it was read. */
                            hasAlpha: boolean | null;
                            heightPx: number | null;
                            id: string;
                            kind: string;
                            /** @description Its name per customer-facing language, by code; a language left out shows its own name. */
                            localizedNames: {
                                [key: string]: string;
                            };
                            mime: string;
                            name: string | null;
                            /** @description A link to a library picture's preview that opens with no key, for an hour or two. Null for an asset of another kind. */
                            pictureUrl: string | null;
                            retained: boolean;
                            /** @description `picture`, or `blank-photo` for a blank's product photo, which is in no category and counted in no category or tag. */
                            role: string;
                            sessionId: string | null;
                            sizeBytes: number;
                            tags: string[];
                            templateId: string | null;
                            /** @description When the asset's name, visibility, category or tags last changed: what a PATCH's `expectedUpdatedAt` names. */
                            updatedAt: number;
                            /** @description The picture this asset is an upscale of, at the size it was then; null when it is not an upscale. */
                            upscaledFrom: {
                                assetId: string;
                                /** @description Whether the source is still in the library: false once it was deleted, since the record outlives its source. */
                                inLibrary: boolean;
                                /** @description The source's name, or null when it has none or is no longer in the library. */
                                name: string | null;
                                sourceHeightPx: number;
                                sourceWidthPx: number;
                            } | null;
                            visibility: string;
                            widthPx: number | null;
                        }[];
                        page: number;
                        pageSize: number;
                        total: number;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: invalid_query */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "assets.create": {
        parameters: {
            query?: never;
            header?: {
                /** @description The designer's browser session, which the SDK sends so one visitor's uploads and proofs are told apart from another's on the same key: 6 to 64 letters, digits, `_` or `-`. Any other value is ignored. */
                "x-pixonaut-session"?: string;
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    heightMm?: number | null;
                    /** @enum {string} */
                    kind?: "library" | "design-upload" | "mockup";
                    layerId?: string | null;
                    /**
                     * @description The file's mime type. A template the upload names may take fewer than the platform does.
                     * @enum {string}
                     */
                    mime?: "image/png" | "image/jpeg" | "image/webp" | "image/heic" | "image/heif";
                    name?: string;
                    /**
                     * @description A library asset's role: `picture`, the default, or `blank-photo` for a blank's product photo, which is listed apart and in no category.
                     * @enum {string}
                     */
                    role?: "picture" | "blank-photo";
                    /** @description The file's size in bytes. The upload must send exactly this many. At most 268435456 for a PNG and 83886080 for any other format, and a template the upload names may allow fewer. */
                    sizeBytes?: number;
                    templateId?: string | null;
                    /** @enum {string} */
                    visibility?: "public" | "private";
                    widthMm?: number | null;
                } & {
                    [key: string]: unknown;
                };
            };
        };
        responses: {
            /** @description The upload is ready for its bytes */
            201: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description `uploadUrl` on this API's public address, for a caller that holds no base to resolve it against. */
                        absoluteUploadUrl: string;
                        assetId: string;
                        uploadUrl: string;
                    };
                };
            };
            /** @description Refused: bad_json */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, feature_disabled, forbidden, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: unsupported_mime, size_out_of_bounds, payload_too_large, invalid_input, invalid_kind, invalid_visibility, invalid_role */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Always sent with `unsupported_mime`. */
                        allowed?: string[];
                        /** @description Sent with `payload_too_large`. */
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `size_out_of_bounds`, `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
            /** @description Refused: lock_timeout */
            503: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: storage_quota_exceeded. The tenant's storage quota would be exceeded. `usedBytes` and `quotaBytes` are left out for a publishable key. A publishable key or a share link is also refused this way once the tenant's customers have uploaded their plan's daily allowance in the last 24 hours. */
            507: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `storage_quota_exceeded`. */
                        quotaBytes?: number;
                        /** @description Always sent with `storage_quota_exceeded`. */
                        usedBytes?: number;
                    };
                };
            };
        };
    };
    "assets.bulkUpdate": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @enum {string} */
                    action: "retain" | "delete";
                    ids: string[];
                };
            };
        };
        responses: {
            /** @description Each id's answer */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        results: ({
                            id: string;
                            /** @enum {boolean} */
                            ok: true;
                        } | {
                            error: string;
                            id: string;
                            /** @enum {boolean} */
                            ok: false;
                        } | {
                            error: string;
                            id: string;
                            /** @enum {boolean} */
                            ok: false;
                            referencedBy: {
                                baseId: string;
                                version: number | null;
                            }[];
                        })[];
                    };
                };
            };
            /** @description Refused: bad_json */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: payload_too_large, invalid_input */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Sent with `payload_too_large`. */
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "assets.import": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description The category to put it in: its id, as list_asset_categories returns it. Left out, it is in none. */
                    categoryId?: string;
                    /** @description The picture's bytes, base64, at most 655360 bytes before encoding; a larger one is sent by `url`. Give this or `url`. */
                    data?: string;
                    /** @description The picture's name in the library, e.g. `Summer logo`. */
                    name?: string;
                    /** @description The picture's tags: lowercase words, e.g. `summer`, `logo`. At most 100. */
                    tags?: string[];
                    /**
                     * Format: uri
                     * @description Where to fetch the picture: a public http(s) URL answering with the image itself. Give this or `data`.
                     */
                    url?: string;
                };
            };
        };
        responses: {
            /** @description The picture is in the library */
            201: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        assetId: string;
                        categoryId: string | null;
                        heightPx: number;
                        name: string | null;
                        tags: string[];
                        widthPx: number;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: size_mismatch, unsupported_mime, animation_not_supported, not_a_valid_image, pixel_dimensions_too_large, size_out_of_bounds, invalid_tag, unknown_category, url_refused, payload_too_large, invalid_input */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Always sent with `unsupported_mime`. */
                        allowed?: string[];
                        /** @description Sent with `payload_too_large`. */
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `pixel_dimensions_too_large`. */
                        heightPx?: number;
                        /** @description Sent with `url_refused`. */
                        host?: string;
                        /** @description Always sent with `size_out_of_bounds`, `payload_too_large`. */
                        maxBytes?: number;
                        /** @description Sent with `pixel_dimensions_too_large`. */
                        maxEdgePx?: number;
                        /** @description Sent with `pixel_dimensions_too_large`. */
                        maxPixels?: number;
                        /** @description Always sent with `url_refused`. */
                        reason?: string;
                        /** @description Always sent with `invalid_tag`. */
                        tag?: string;
                        /** @description Always sent with `pixel_dimensions_too_large`. */
                        widthPx?: number;
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: preview_failed, import_failed, db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
            /** @description Refused: fetch_failed */
            502: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        status?: number;
                        timedOut?: boolean;
                    };
                };
            };
            /** @description Refused: lock_timeout */
            503: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: storage_quota_exceeded. The tenant's storage quota would be exceeded. `usedBytes` and `quotaBytes` are left out for a publishable key. */
            507: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `storage_quota_exceeded`. */
                        quotaBytes?: number;
                        /** @description Always sent with `storage_quota_exceeded`. */
                        usedBytes?: number;
                    };
                };
            };
        };
    };
    "assets.get": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The asset */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        categoryId: string | null;
                        /** @description The stored picture's colour model: `cmyk` for a CMYK JPEG, kept as uploaded. Null until it was read. */
                        colourModel: string | null;
                        /** @description The description of the colour profile the picture embeds, such as `sRGB IEC61966-2.1`. Null when it embeds none. */
                        colourProfile: string | null;
                        /** @description Names the asset's stored bytes, which never change. Pass it as `v` to `/v1/assets/{id}/content` and the answer is cached `immutable`. */
                        contentKey: string | null;
                        createdAt: number;
                        expiresAt: number;
                        /** @description Whether any pixel of the picture is not fully opaque. Null until it was read. */
                        hasAlpha: boolean | null;
                        heightPx: number | null;
                        id: string;
                        kind: string;
                        /** @description Its name per customer-facing language, by code; a language left out shows its own name. */
                        localizedNames: {
                            [key: string]: string;
                        };
                        mime: string;
                        name: string | null;
                        /** @description A link to a library picture's preview that opens with no key, for an hour or two. Null for an asset of another kind. */
                        pictureUrl: string | null;
                        retained: boolean;
                        /** @description `picture`, or `blank-photo` for a blank's product photo, which is in no category and counted in no category or tag. */
                        role: string;
                        sessionId: string | null;
                        sizeBytes: number;
                        tags: string[];
                        templateId: string | null;
                        /** @description When the asset's name, visibility, category or tags last changed: what a PATCH's `expectedUpdatedAt` names. */
                        updatedAt: number;
                        /** @description The picture this asset is an upscale of, at the size it was then; null when it is not an upscale. */
                        upscaledFrom: {
                            assetId: string;
                            /** @description Whether the source is still in the library: false once it was deleted, since the record outlives its source. */
                            inLibrary: boolean;
                            /** @description The source's name, or null when it has none or is no longer in the library. */
                            name: string | null;
                            sourceHeightPx: number;
                            sourceWidthPx: number;
                        } | null;
                        visibility: string;
                        widthPx: number | null;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "assets.delete": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The asset was deleted */
            204: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: template_referenced, blank_referenced, logo_referenced, order_referenced, delete_failed */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `template_referenced`. */
                        referencedBy?: {
                            baseId: string;
                            version: number | null;
                        }[];
                    };
                };
            };
            /** @description Refused: payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "assets.update": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description The id of a category, as list_asset_categories returns it, or null to take the picture out of its category. */
                    categoryId?: string | null;
                    /** @description The picture's updatedAt, as list_assets returned it. The change is refused if the picture changed since. */
                    expectedUpdatedAt?: number;
                    /** @description Its name per customer-facing language, by code (`en`, `sv`, `de`, `fr`, `es`, `nl`, `da`, `nb`, `fi`), e.g. `{"de": "Stern"}`. Replaces every name it had; a language left out shows its own name. */
                    localizedNames?: {
                        da?: string;
                        de?: string;
                        en?: string;
                        es?: string;
                        fi?: string;
                        fr?: string;
                        nb?: string;
                        nl?: string;
                        sv?: string;
                    };
                    /** @description The picture's new name; it cannot be empty. */
                    name?: string;
                    /**
                     * @description `picture`, or `blank-photo` for a blank's product photo. A blank photo is in no category.
                     * @enum {string}
                     */
                    role?: "picture" | "blank-photo";
                    /** @description The picture's whole tag list, replacing the current one: lowercase words, e.g. `summer`, `logo`. At most 100. */
                    tags?: string[];
                    /**
                     * @description `public` lets the picture be offered to customers; `private` keeps it to the tenant.
                     * @enum {string}
                     */
                    visibility?: "public" | "private";
                };
            };
        };
        responses: {
            /** @description The updated asset */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        categoryId: string | null;
                        createdAt: number;
                        heightPx: number | null;
                        id: string;
                        /** @description Its name per customer-facing language, by code; a language left out shows its own name. */
                        localizedNames: {
                            [key: string]: string;
                        };
                        mime: string;
                        name: string | null;
                        /** @description `picture`, or `blank-photo` for a blank's product photo, which is in no category and counted in no category or tag. */
                        role: string;
                        sizeBytes: number;
                        tags: string[];
                        /** @description When the asset's name, visibility, category or tags last changed: what a PATCH's `expectedUpdatedAt` names. */
                        updatedAt: number;
                        visibility: string;
                        widthPx: number | null;
                    };
                };
            };
            /** @description Refused: bad_json */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: stale_update */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Always sent with `stale_update`. */
                        current?: {
                            categoryId: string | null;
                            createdAt: number;
                            heightPx: number | null;
                            id: string;
                            /** @description Its name per customer-facing language, by code; a language left out shows its own name. */
                            localizedNames: {
                                [key: string]: string;
                            };
                            mime: string;
                            name: string | null;
                            /** @description `picture`, or `blank-photo` for a blank's product photo, which is in no category and counted in no category or tag. */
                            role: string;
                            sizeBytes: number;
                            tags: string[];
                            /** @description When the asset's name, visibility, category or tags last changed: what a PATCH's `expectedUpdatedAt` names. */
                            updatedAt: number;
                            visibility: string;
                            widthPx: number | null;
                        };
                        error: string;
                    };
                };
            };
            /** @description Refused: invalid_tag, unknown_category, blank_photo_uncategorised, payload_too_large, invalid_input, invalid_name, invalid_visibility, invalid_role, invalid_tags */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Sent with `payload_too_large`. */
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                        /** @description Always sent with `invalid_tag`. */
                        tag?: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
            /** @description Refused: lock_timeout */
            503: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
        };
    };
    "assets.content.get": {
        parameters: {
            query?: {
                /** @description The asset's `contentKey`. When it matches, the answer is cached `immutable`. */
                v?: string;
                /** @description The width in pixels the image is drawn at. The long edge served is derived from the image's own ratio, never larger than the stored image, and clamped to the sizes the api serves. */
                width?: string;
                /** @description `cover` when the image is cropped to fill its box: `width` is then its short edge. */
                fit?: "cover";
            };
            header?: {
                /** @description The designer's browser session, which the SDK sends so one visitor's uploads and proofs are told apart from another's on the same key: 6 to 64 letters, digits, `_` or `-`. Any other value is ignored. */
                "x-pixonaut-session"?: string;
            };
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The file's bytes */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    /** @description The uploaded file's height in pixels, when it is known. The bytes served may be a smaller preview. */
                    "x-pixonaut-original-height"?: number;
                    /** @description The uploaded file's width in pixels, when it is known. The bytes served may be a smaller preview. */
                    "x-pixonaut-original-width"?: number;
                    [name: string]: unknown;
                };
                content: {
                    "image/heic": string;
                    "image/heif": string;
                    "image/jpeg": string;
                    "image/png": string;
                    "image/webp": string;
                };
            };
            /** @description Not modified: the `If-None-Match` etag still holds */
            304: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, feature_disabled, forbidden, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description No such finished asset (plain text) */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Refused: invalid_query */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "assets.cutOutStatus": {
        parameters: {
            query?: never;
            header?: {
                /** @description The designer's browser session, which the SDK sends so one visitor's uploads and proofs are told apart from another's on the same key: 6 to 64 letters, digits, `_` or `-`. Any other value is ignored. */
                "x-pixonaut-session"?: string;
            };
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description How the cut-out stands */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description How often the cut-out was asked, at most 2: a cut-out that failed may be asked once more. */
                        attempts: number;
                        /** @description The cut-out, once done: a new upload for the same picture, to put in the upload's place. Null while it runs, after it failed, or once it is no longer kept. */
                        cutOut: {
                            assetId: string;
                            contentKey: string;
                            heightPx: number;
                            widthPx: number;
                        } | null;
                        /** @description Failed, and it may be asked again. Once false on a failed cut-out, the customer goes on with the upload as it was. */
                        retryable: boolean;
                        /** @description `running` while it is being cut out; `done` once the cut-out is kept; `failed` when it could not be cut out, which charged nothing. */
                        status: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "assets.cutOut": {
        parameters: {
            query?: never;
            header?: {
                /** @description The designer's browser session, which the SDK sends so one visitor's uploads and proofs are told apart from another's on the same key: 6 to 64 letters, digits, `_` or `-`. Any other value is ignored. */
                "x-pixonaut-session"?: string;
            };
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The cut-out asked already, as it stands: asked again, as when an answer was lost */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description How often the cut-out was asked, at most 2: a cut-out that failed may be asked once more. */
                        attempts: number;
                        /** @description The cut-out, once done: a new upload for the same picture, to put in the upload's place. Null while it runs, after it failed, or once it is no longer kept. */
                        cutOut: {
                            assetId: string;
                            contentKey: string;
                            heightPx: number;
                            widthPx: number;
                        } | null;
                        /** @description Failed, and it may be asked again. Once false on a failed cut-out, the customer goes on with the upload as it was. */
                        retryable: boolean;
                        /** @description `running` while it is being cut out; `done` once the cut-out is kept; `failed` when it could not be cut out, which charged nothing. */
                        status: string;
                    };
                };
            };
            /** @description The cut-out, accepted and running */
            202: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description How often the cut-out was asked, at most 2: a cut-out that failed may be asked once more. */
                        attempts: number;
                        /** @description The cut-out, once done: a new upload for the same picture, to put in the upload's place. Null while it runs, after it failed, or once it is no longer kept. */
                        cutOut: {
                            assetId: string;
                            contentKey: string;
                            heightPx: number;
                            widthPx: number;
                        } | null;
                        /** @description Failed, and it may be asked again. Once false on a failed cut-out, the customer goes on with the upload as it was. */
                        retryable: boolean;
                        /** @description `running` while it is being cut out; `done` once the cut-out is kept; `failed` when it could not be cut out, which charged nothing. */
                        status: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: insufficient_credits. The tenant's credits cannot cover this action, its spending cap has no room left for it, a storefront's customer asked and the tenant's daily storefront ceiling has no room left, or the account that created the tenant has not confirmed its email address yet, so none of it was done. `reason` says which: `balance`, `spending_cap`, `storefront_ceiling` or `email_unverified`. `requiredCredits`, `availableCredits` and `reason` are left out for a publishable key. */
            402: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Always sent with `insufficient_credits`. */
                        availableCredits?: number;
                        error: string;
                        /** @description Always sent with `insufficient_credits`. */
                        reason?: string;
                        /** @description Always sent with `insufficient_credits`. */
                        requiredCredits?: number;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: cut_out_exhausted */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description How often the cut-out was asked, at most 2: a cut-out that failed may be asked once more. Always sent with `cut_out_exhausted`. */
                        attempts?: number;
                        /** @description The cut-out, once done: a new upload for the same picture, to put in the upload's place. Null while it runs, after it failed, or once it is no longer kept. Always sent with `cut_out_exhausted`. */
                        cutOut?: {
                            assetId: string;
                            contentKey: string;
                            heightPx: number;
                            widthPx: number;
                        } | null;
                        error: string;
                        /** @description Failed, and it may be asked again. Once false on a failed cut-out, the customer goes on with the upload as it was. Always sent with `cut_out_exhausted`. */
                        retryable?: boolean;
                        /** @description `running` while it is being cut out; `done` once the cut-out is kept; `failed` when it could not be cut out, which charged nothing. Always sent with `cut_out_exhausted`. */
                        status?: string;
                    };
                };
            };
            /** @description Refused: cut_out_not_offered, payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Sent with `payload_too_large`. */
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
            /** @description Refused: lock_timeout, cut_out_unavailable */
            503: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: storage_quota_exceeded. The tenant's storage quota would be exceeded. `usedBytes` and `quotaBytes` are left out for a publishable key. */
            507: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `storage_quota_exceeded`. */
                        quotaBytes?: number;
                        /** @description Always sent with `storage_quota_exceeded`. */
                        usedBytes?: number;
                    };
                };
            };
        };
    };
    "assets.improveResolution": {
        parameters: {
            query?: never;
            header?: {
                /** @description The designer's browser session, which the SDK sends so one visitor's uploads and proofs are told apart from another's on the same key: 6 to 64 letters, digits, `_` or `-`. Any other value is ignored. */
                "x-pixonaut-session"?: string;
            };
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The improved upload, delivered already: asked again, as when an answer was lost */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        assetId: string;
                        contentKey: string;
                        heightPx: number;
                        sourceAssetId: string;
                        widthPx: number;
                    };
                };
            };
            /** @description The improved upload */
            201: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        assetId: string;
                        contentKey: string;
                        heightPx: number;
                        sourceAssetId: string;
                        widthPx: number;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: insufficient_credits. The tenant's credits cannot cover this action, its spending cap has no room left for it, a storefront's customer asked and the tenant's daily storefront ceiling has no room left, or the account that created the tenant has not confirmed its email address yet, so none of it was done. `reason` says which: `balance`, `spending_cap`, `storefront_ceiling` or `email_unverified`. `requiredCredits`, `availableCredits` and `reason` are left out for a publishable key. */
            402: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Always sent with `insufficient_credits`. */
                        availableCredits?: number;
                        error: string;
                        /** @description Always sent with `insufficient_credits`. */
                        reason?: string;
                        /** @description Always sent with `insufficient_credits`. */
                        requiredCredits?: number;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: already_improved */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: not_improvable, payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Sent with `payload_too_large`. */
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
            /** @description Refused: lock_timeout, upscale_unavailable, upscale_failed, upscale_timed_out, aborted */
            503: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: storage_quota_exceeded. The tenant's storage quota would be exceeded. `usedBytes` and `quotaBytes` are left out for a publishable key. */
            507: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `storage_quota_exceeded`. */
                        quotaBytes?: number;
                        /** @description Always sent with `storage_quota_exceeded`. */
                        usedBytes?: number;
                    };
                };
            };
        };
    };
    "assets.original.get": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The file's bytes */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    /** @description The uploaded file's height in pixels, when it is known. The bytes served may be a smaller preview. */
                    "x-pixonaut-original-height"?: number;
                    /** @description The uploaded file's width in pixels, when it is known. The bytes served may be a smaller preview. */
                    "x-pixonaut-original-width"?: number;
                    [name: string]: unknown;
                };
                content: {
                    "image/heic": string;
                    "image/heif": string;
                    "image/jpeg": string;
                    "image/png": string;
                    "image/webp": string;
                };
            };
            /** @description Not modified: the `If-None-Match` etag still holds */
            304: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description No such finished asset (plain text) */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "assets.roundShapes.get": {
        parameters: {
            query?: {
                /** @description An artwork's aspect ratio as `w:h` (`3:4`): each shape is also placed where it lands with the picture as that artwork's background at its default fit, cover. */
                ratio?: string;
            };
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The round shapes found */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        heightPx: number;
                        /** @description The round shapes found, the largest first: in fractions of the picture, and on the artwork. */
                        shapes: {
                            /** @description The centre, as fractions of the width and height. */
                            center: {
                                x: number;
                                y: number;
                            };
                            /** @description A ring's inner edge's radius; null for a disc or a circle. */
                            innerRadius: {
                                h: number;
                                w: number;
                            } | null;
                            /** @description The shape on the artwork asked for with `ratio`, in fractions of the artwork, ignoring the few millimetres of a print's bleed; null without `ratio`. */
                            onArtwork: {
                                /** @description The square round the outer edge, as fractions of the artwork from its top-left corner: a layer's offset and size that ring the shape. */
                                box: {
                                    h: number;
                                    w: number;
                                    x: number;
                                    y: number;
                                };
                                /** @description The centre, as fractions of the width and height. */
                                center: {
                                    x: number;
                                    y: number;
                                };
                                /** @description A ring's inner edge's radius; null for a disc or a circle. */
                                innerRadius: {
                                    h: number;
                                    w: number;
                                } | null;
                                /** @description The outer edge's radius. */
                                radius: {
                                    h: number;
                                    w: number;
                                };
                            } | null;
                            /** @description The outer edge's radius. */
                            radius: {
                                h: number;
                                w: number;
                            };
                        }[];
                        widthPx: number;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: not_a_picture, invalid_query */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "assets.usage.get": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Where the asset is used */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Every blank mockup photo the asset is. */
                        blanks: {
                            blankId: string;
                            mockupId: string | null;
                            name: string;
                            /** @description The mockup photo's label, such as the colour it shows. */
                            photo: string | null;
                            placementId: string | null;
                        }[];
                        /** @description Every committed design that names the asset and has no order yet: it keeps the picture as an order does. */
                        designs: {
                            designId: string;
                            externalRef: string | null;
                            status: string;
                        }[];
                        /** @description Whether the asset is the workspace logo. */
                        logo: boolean;
                        /** @description Every order of a print of a design that names the asset. */
                        orders: {
                            externalRef: string | null;
                            orderId: string;
                            status: string;
                        }[];
                        /** @description Every template whose draft (`version: null`) or a published version names the asset. */
                        templates: {
                            baseId: string;
                            deleted: boolean;
                            name: string;
                            version: number | null;
                        }[];
                        /** @description What the answer leaves out for want of a grant, so an empty group is not read as an unused asset. A secret key is shown everything. */
                        withheld: {
                            /** @description How many designs `designs` leaves out because the caller may not read designs (`designs:read`); 0 when they are listed. */
                            designs: number;
                            /** @description How many orders `orders` leaves out because the caller may not read orders (`orders:read`); 0 when they are listed. */
                            orders: number;
                        };
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "automations.list": {
        parameters: {
            query?: {
                /** @description The page to read, from 1; the first when left out. */
                page?: number;
                pageSize?: number;
                /** @description Only the automations whose name or trigger holds this text, case aside. */
                q?: string;
                /** @description Only the automations that fire on this event. */
                trigger?: "design.committed" | "design.approved" | "design.changes_requested" | "design.delivery_captured" | "print.completed" | "print.failed" | "order.submitted" | "order.status_changed" | "order.failed" | "order.cancelled" | "order.delivery_changed";
                /** @description Only the automations that act at this printshop, by its id: a step names it, or a step orders at the blank's printshop and one of your blanks prints there. Each row then says which of its steps act there. */
                printshop?: string;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description A page of automations */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        automations: {
                            /** @description With `printshop`: the steps that act at that printshop. */
                            atPrintshop?: {
                                /** @description `named`: the step names the printshop. `blank`: it orders at the blank's printshop, and a blank prints there. */
                                reach: string;
                                stepId: string;
                                type: string;
                            }[];
                            /** @description The member whose grants it acts with: whoever last saved it. Null when it runs as the workspace. */
                            author: {
                                name: string | null;
                                userId: string;
                            } | null;
                            /** @description The automation's tree of steps. */
                            body: {
                                /** @description When its steps run: conditions on the subject, combined with `all`, `any` and `not`. Left out, whenever the trigger happens in its sources. */
                                conditions?: {
                                    /** @description Every one holds. */
                                    all: unknown[];
                                } | {
                                    /** @description At least one holds. */
                                    any: unknown[];
                                } | {
                                    /** @description It does not hold. */
                                    not?: unknown;
                                } | {
                                    /** @description The fact compared. */
                                    field: string;
                                    /** @description It holds when the fact is one of these: each at most 200 characters, or 2054 for an origin, which may name a store's site. */
                                    in: string[];
                                } | {
                                    /** @description It holds from this many copies up. */
                                    atLeast?: number;
                                    /** @description It holds up to this many copies. */
                                    atMost?: number;
                                    /**
                                     * @description The order's quantity.
                                     * @enum {string}
                                     */
                                    field: "quantity";
                                } | {
                                    /**
                                     * @description The order's delivery address.
                                     * @enum {string}
                                     */
                                    field: "delivery_address";
                                    /** @description Whether it must be set, or must not. */
                                    present: boolean;
                                };
                                /** @description The steps, in the order they run. A step's `type` names an action from the catalogue. */
                                steps: {
                                    /** @description Further steps, under each branch's name. */
                                    branches?: {
                                        [key: string]: unknown[];
                                    };
                                    /** @description Its id, unique in the body: what a firing names it by. */
                                    id: string;
                                    /**
                                     * @description What its type takes; the draft check refuses settings the type does not.
                                     * @default {}
                                     */
                                    settings: {
                                        [key: string]: unknown;
                                    };
                                    /** @description Its action (approve, create_print, place_order, reroute, cancel_order, notify, email, webhook) or flow step (only_if, paths, wait_for, delay). */
                                    type: string;
                                }[];
                            };
                            createdAt: number;
                            enabled: boolean;
                            /** @description When it was last enabled: it never fires on an event from before. Null for one never enabled. */
                            enabledAt: number | null;
                            firings: {
                                count: number;
                                lastAt: number | null;
                                paused: number;
                                /** @description Spend actions it took in the last 24 hours, against its spend limit. */
                                spentToday: number;
                                waiting: number;
                            };
                            id: string;
                            name: string;
                            runsAs: string;
                            /** @description The sources it acts on: the studio always; designer links, keys and connected stores, each every one or a snapshot. To act on only some, an Only if compares the design's `origin`. */
                            sources: {
                                /** @description On, it acts on designs from every secret and publishable key no store was given, those added later too. Off, only from those in `keys`. */
                                includeNewKeys: boolean;
                                /** @description On, it acts on designs from every designer link, those made later too. Off, only from the links in `links`. */
                                includeNewLinks: boolean;
                                /** @description On, it acts on designs from every connected store, those connected later too. Off, only from those in `stores`. A store may have its own automated flows on its designs; if it does, the first to move one on wins. */
                                includeNewStores: boolean;
                                /** @description While its switch is off, those that existed when it was switched off; null while it is on. A save that turns it off with none takes it then. */
                                keys: {
                                    /** @description Each one that existed then, as a design's origin names it: `link:<id>`, `secret_key:<id>` and `publishable_key:<id>`, or `store:<site>`. */
                                    sources: string[];
                                    /** @description When its switch was turned off: the snapshot is as of then. */
                                    takenAt: number;
                                } | null;
                                /** @description While its switch is off, those that existed when it was switched off; null while it is on. A save that turns it off with none takes it then. */
                                links: {
                                    /** @description Each one that existed then, as a design's origin names it: `link:<id>`, `secret_key:<id>` and `publishable_key:<id>`, or `store:<site>`. */
                                    sources: string[];
                                    /** @description When its switch was turned off: the snapshot is as of then. */
                                    takenAt: number;
                                } | null;
                                /** @description While its switch is off, those that existed when it was switched off; null while it is on. A save that turns it off with none takes it then. */
                                stores: {
                                    /** @description Each one that existed then, as a design's origin names it: `link:<id>`, `secret_key:<id>` and `publishable_key:<id>`, or `store:<site>`. */
                                    sources: string[];
                                    /** @description When its switch was turned off: the snapshot is as of then. */
                                    takenAt: number;
                                } | null;
                            };
                            spendLimit: number;
                            /** @description Where it stands: `enabled` or `disabled`; `failing` while its latest firing failed; `broken` while it cannot fire at all, because its author lacks a grant it needs. `reason` says why, in words. */
                            standing: {
                                state: string;
                            } | {
                                reason: string;
                                /** @enum {string} */
                                state: "failing";
                            } | {
                                code: string;
                                reason: string;
                                /** @enum {string} */
                                state: "broken";
                            };
                            /** @description The event it fires on; null for none yet. */
                            trigger: string | null;
                            /** @description When it was last saved: a save names it as `expectedUpdatedAt`. */
                            updatedAt: number;
                            /** @description Its current version. */
                            version: number;
                        }[];
                        page: number;
                        pageSize: number;
                        /** @description How many there are in all. */
                        total: number;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: invalid_query */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "automations.create": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /**
                     * @description The automation's tree of steps.
                     * @default {
                     *       "steps": []
                     *     }
                     */
                    body?: {
                        /** @description When its steps run: conditions on the subject, combined with `all`, `any` and `not`. Left out, whenever the trigger happens in its sources. */
                        conditions?: {
                            /** @description Every one holds. */
                            all: unknown[];
                        } | {
                            /** @description At least one holds. */
                            any: unknown[];
                        } | {
                            /** @description It does not hold. */
                            not?: unknown;
                        } | {
                            /**
                             * @description The fact compared.
                             * @enum {string}
                             */
                            field: "origin" | "template" | "tag" | "category" | "blank" | "variant" | "printshop" | "order_status" | "failure_kind" | "delivery_outcome" | "caused_by_automation";
                            /** @description It holds when the fact is one of these: each at most 200 characters, or 2054 for an origin, which may name a store's site. */
                            in: string[];
                        } | {
                            /** @description It holds from this many copies up. */
                            atLeast?: number;
                            /** @description It holds up to this many copies. */
                            atMost?: number;
                            /**
                             * @description The order's quantity.
                             * @enum {string}
                             */
                            field: "quantity";
                        } | {
                            /**
                             * @description The order's delivery address.
                             * @enum {string}
                             */
                            field: "delivery_address";
                            /** @description Whether it must be set, or must not. */
                            present: boolean;
                        };
                        /** @description The steps, in the order they run. A step's `type` names an action from the catalogue. */
                        steps: {
                            /** @description Further steps, under each branch's name. */
                            branches?: {
                                [key: string]: unknown[];
                            };
                            /** @description Its id, unique in the body: what a firing names it by. */
                            id: string;
                            /**
                             * @description What its type takes; the draft check refuses settings the type does not.
                             * @default {}
                             */
                            settings?: {
                                [key: string]: unknown;
                            };
                            /** @description Its action (approve, create_print, place_order, reroute, cancel_order, notify, email, webhook) or flow step (only_if, paths, wait_for, delay). */
                            type: string;
                        }[];
                    };
                    /** @description Confirms that the automation spends without a person, at most its spend limit in 24 hours. Required, true, when it holds a spend action (create print, place order, reroute); a save without it is refused `spend_unconfirmed`. */
                    confirmSpend?: boolean;
                    /** @description What members call it. Left out: "Automation N", one past the highest such name in the workspace. */
                    name?: string;
                    /**
                     * @description Whose grants it acts with. Left out: its author, the member making it; or the workspace, when a secret key makes it.
                     * @enum {string}
                     */
                    runsAs?: "author" | "workspace";
                    /** @description Left out: every designer link and key, those to come too, and no store. */
                    sources?: {
                        /** @description On, it acts on designs from every secret and publishable key no store was given, those added later too. Off, only from those in `keys`. */
                        includeNewKeys: boolean;
                        /** @description On, it acts on designs from every designer link, those made later too. Off, only from the links in `links`. */
                        includeNewLinks: boolean;
                        /** @description On, it acts on designs from every connected store, those connected later too. Off, only from those in `stores`. A store may have its own automated flows on its designs; if it does, the first to move one on wins. */
                        includeNewStores: boolean;
                        /** @description While its switch is off, those that existed when it was switched off; null while it is on. A save that turns it off with none takes it then. */
                        keys?: {
                            /** @description Each one that existed then, as a design's origin names it: `link:<id>`, `secret_key:<id>` and `publishable_key:<id>`, or `store:<site>`. */
                            sources: string[];
                            /** @description When its switch was turned off: the snapshot is as of then. */
                            takenAt: number;
                        } | null;
                        /** @description While its switch is off, those that existed when it was switched off; null while it is on. A save that turns it off with none takes it then. */
                        links?: {
                            /** @description Each one that existed then, as a design's origin names it: `link:<id>`, `secret_key:<id>` and `publishable_key:<id>`, or `store:<site>`. */
                            sources: string[];
                            /** @description When its switch was turned off: the snapshot is as of then. */
                            takenAt: number;
                        } | null;
                        /** @description While its switch is off, those that existed when it was switched off; null while it is on. A save that turns it off with none takes it then. */
                        stores?: {
                            /** @description Each one that existed then, as a design's origin names it: `link:<id>`, `secret_key:<id>` and `publishable_key:<id>`, or `store:<site>`. */
                            sources: string[];
                            /** @description When its switch was turned off: the snapshot is as of then. */
                            takenAt: number;
                        } | null;
                    };
                    /**
                     * @description Spend actions it may take per rolling 24 hours.
                     * @default 50
                     */
                    spendLimit?: number;
                    /**
                     * @description The event it fires on. Left out: none yet, which fires on nothing.
                     * @default null
                     * @enum {string|null}
                     */
                    trigger?: "design.committed" | "design.approved" | "design.changes_requested" | "design.delivery_captured" | "print.completed" | "print.failed" | "order.submitted" | "order.status_changed" | "order.failed" | "order.cancelled" | "order.delivery_changed" | null;
                };
            };
        };
        responses: {
            /** @description The automation */
            201: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description The member whose grants it acts with: whoever last saved it. Null when it runs as the workspace. */
                        author: {
                            name: string | null;
                            userId: string;
                        } | null;
                        /** @description The automation's tree of steps. */
                        body: {
                            /** @description When its steps run: conditions on the subject, combined with `all`, `any` and `not`. Left out, whenever the trigger happens in its sources. */
                            conditions?: {
                                /** @description Every one holds. */
                                all: unknown[];
                            } | {
                                /** @description At least one holds. */
                                any: unknown[];
                            } | {
                                /** @description It does not hold. */
                                not?: unknown;
                            } | {
                                /** @description The fact compared. */
                                field: string;
                                /** @description It holds when the fact is one of these: each at most 200 characters, or 2054 for an origin, which may name a store's site. */
                                in: string[];
                            } | {
                                /** @description It holds from this many copies up. */
                                atLeast?: number;
                                /** @description It holds up to this many copies. */
                                atMost?: number;
                                /**
                                 * @description The order's quantity.
                                 * @enum {string}
                                 */
                                field: "quantity";
                            } | {
                                /**
                                 * @description The order's delivery address.
                                 * @enum {string}
                                 */
                                field: "delivery_address";
                                /** @description Whether it must be set, or must not. */
                                present: boolean;
                            };
                            /** @description The steps, in the order they run. A step's `type` names an action from the catalogue. */
                            steps: {
                                /** @description Further steps, under each branch's name. */
                                branches?: {
                                    [key: string]: unknown[];
                                };
                                /** @description Its id, unique in the body: what a firing names it by. */
                                id: string;
                                /**
                                 * @description What its type takes; the draft check refuses settings the type does not.
                                 * @default {}
                                 */
                                settings: {
                                    [key: string]: unknown;
                                };
                                /** @description Its action (approve, create_print, place_order, reroute, cancel_order, notify, email, webhook) or flow step (only_if, paths, wait_for, delay). */
                                type: string;
                            }[];
                        };
                        createdAt: number;
                        enabled: boolean;
                        /** @description When it was last enabled: it never fires on an event from before. Null for one never enabled. */
                        enabledAt: number | null;
                        firings: {
                            count: number;
                            lastAt: number | null;
                            paused: number;
                            /** @description Spend actions it took in the last 24 hours, against its spend limit. */
                            spentToday: number;
                            waiting: number;
                        };
                        id: string;
                        name: string;
                        runsAs: string;
                        /** @description The sources it acts on: the studio always; designer links, keys and connected stores, each every one or a snapshot. To act on only some, an Only if compares the design's `origin`. */
                        sources: {
                            /** @description On, it acts on designs from every secret and publishable key no store was given, those added later too. Off, only from those in `keys`. */
                            includeNewKeys: boolean;
                            /** @description On, it acts on designs from every designer link, those made later too. Off, only from the links in `links`. */
                            includeNewLinks: boolean;
                            /** @description On, it acts on designs from every connected store, those connected later too. Off, only from those in `stores`. A store may have its own automated flows on its designs; if it does, the first to move one on wins. */
                            includeNewStores: boolean;
                            /** @description While its switch is off, those that existed when it was switched off; null while it is on. A save that turns it off with none takes it then. */
                            keys: {
                                /** @description Each one that existed then, as a design's origin names it: `link:<id>`, `secret_key:<id>` and `publishable_key:<id>`, or `store:<site>`. */
                                sources: string[];
                                /** @description When its switch was turned off: the snapshot is as of then. */
                                takenAt: number;
                            } | null;
                            /** @description While its switch is off, those that existed when it was switched off; null while it is on. A save that turns it off with none takes it then. */
                            links: {
                                /** @description Each one that existed then, as a design's origin names it: `link:<id>`, `secret_key:<id>` and `publishable_key:<id>`, or `store:<site>`. */
                                sources: string[];
                                /** @description When its switch was turned off: the snapshot is as of then. */
                                takenAt: number;
                            } | null;
                            /** @description While its switch is off, those that existed when it was switched off; null while it is on. A save that turns it off with none takes it then. */
                            stores: {
                                /** @description Each one that existed then, as a design's origin names it: `link:<id>`, `secret_key:<id>` and `publishable_key:<id>`, or `store:<site>`. */
                                sources: string[];
                                /** @description When its switch was turned off: the snapshot is as of then. */
                                takenAt: number;
                            } | null;
                        };
                        spendLimit: number;
                        /** @description Where it stands: `enabled` or `disabled`; `failing` while its latest firing failed; `broken` while it cannot fire at all, because its author lacks a grant it needs. `reason` says why, in words. */
                        standing: {
                            state: string;
                        } | {
                            reason: string;
                            /** @enum {string} */
                            state: "failing";
                        } | {
                            code: string;
                            reason: string;
                            /** @enum {string} */
                            state: "broken";
                        };
                        /** @description The event it fires on; null for none yet. */
                        trigger: string | null;
                        /** @description When it was last saved: a save names it as `expectedUpdatedAt`. */
                        updatedAt: number;
                        /** @description Its current version. */
                        version: number;
                    };
                };
            };
            /** @description Refused: invalid_body */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `invalid_body`. */
                        fields?: string[];
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: feature_disabled, admin_only, origin_forbidden, forbidden */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                        /** @description Always sent with `admin_only`. */
                        reason?: string;
                    };
                };
            };
            /** @description Refused: author_needs_member, draft_refused, spend_unconfirmed, spend_limit_over_ceiling, payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Sent with `payload_too_large`. */
                        bytes?: number;
                        /** @description The workspace's ceiling, the most a spend limit may say. Always sent with `spend_limit_over_ceiling`. */
                        ceiling?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                        /** @description Always sent with `author_needs_member`, `spend_unconfirmed`, `spend_limit_over_ceiling`. */
                        reason?: string;
                        /** @description Always sent with `draft_refused`. */
                        refusals?: {
                            code: string;
                            /** @description What is wrong, in words. */
                            message: string;
                            /** @description The step it is about. */
                            stepId?: string;
                        }[];
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "automations.check": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description The automation this draft saves, when it exists: a member who muted it is warned of as not hearing its notifications, and it is left out of the warning of another automation sending the same. */
                    automationId?: string;
                    /** @description The automation's tree of steps. */
                    body: {
                        /** @description When its steps run: conditions on the subject, combined with `all`, `any` and `not`. Left out, whenever the trigger happens in its sources. */
                        conditions?: {
                            /** @description Every one holds. */
                            all: unknown[];
                        } | {
                            /** @description At least one holds. */
                            any: unknown[];
                        } | {
                            /** @description It does not hold. */
                            not?: unknown;
                        } | {
                            /**
                             * @description The fact compared.
                             * @enum {string}
                             */
                            field: "origin" | "template" | "tag" | "category" | "blank" | "variant" | "printshop" | "order_status" | "failure_kind" | "delivery_outcome" | "caused_by_automation";
                            /** @description It holds when the fact is one of these: each at most 200 characters, or 2054 for an origin, which may name a store's site. */
                            in: string[];
                        } | {
                            /** @description It holds from this many copies up. */
                            atLeast?: number;
                            /** @description It holds up to this many copies. */
                            atMost?: number;
                            /**
                             * @description The order's quantity.
                             * @enum {string}
                             */
                            field: "quantity";
                        } | {
                            /**
                             * @description The order's delivery address.
                             * @enum {string}
                             */
                            field: "delivery_address";
                            /** @description Whether it must be set, or must not. */
                            present: boolean;
                        };
                        /** @description The steps, in the order they run. A step's `type` names an action from the catalogue. */
                        steps: {
                            /** @description Further steps, under each branch's name. */
                            branches?: {
                                [key: string]: unknown[];
                            };
                            /** @description Its id, unique in the body: what a firing names it by. */
                            id: string;
                            /**
                             * @description What its type takes; the draft check refuses settings the type does not.
                             * @default {}
                             */
                            settings?: {
                                [key: string]: unknown;
                            };
                            /** @description Its action (approve, create_print, place_order, reroute, cancel_order, notify, email, webhook) or flow step (only_if, paths, wait_for, delay). */
                            type: string;
                        }[];
                    };
                    /**
                     * @default author
                     * @enum {string}
                     */
                    runsAs?: "author" | "workspace";
                    /**
                     * @description The event it fires on; null for none yet, which fires on nothing. One with none cannot be enabled.
                     * @enum {string|null}
                     */
                    trigger: "design.committed" | "design.approved" | "design.changes_requested" | "design.delivery_captured" | "print.completed" | "print.failed" | "order.submitted" | "order.status_changed" | "order.failed" | "order.cancelled" | "order.delivery_changed" | null;
                };
            };
        };
        responses: {
            /** @description The check */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description What a save of this draft refuses. */
                        refusals: {
                            code: string;
                            /** @description What is wrong, in words. */
                            message: string;
                            /** @description The step it is about. */
                            stepId?: string;
                        }[];
                        /** @description Each step that acts at a printshop. */
                        steps: {
                            /** @description Each printshop the step can reach, and what it can do there. */
                            printshops: ({
                                /** @enum {string} */
                                can: "yes";
                                id: string;
                                name: string;
                            } | {
                                /** @enum {string} */
                                can: "no";
                                id: string;
                                name: string;
                                /** @description Why it cannot act there. */
                                reason: string;
                            } | {
                                /** @enum {string} */
                                can: "conditional";
                                id: string;
                                name: string;
                                /** @description When it can: checked when it runs, and a step that meets it unmet is blocked. */
                                rule: string;
                            })[];
                            stepId: string;
                            type: string;
                        }[];
                        /** @description What a save allows, and a member should know. */
                        warnings: {
                            code: string;
                            /** @description What is wrong, in words. */
                            message: string;
                            /** @description The step it is about. */
                            stepId?: string;
                        }[];
                    };
                };
            };
            /** @description Refused: invalid_body */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `invalid_body`. */
                        fields?: string[];
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: feature_disabled, origin_forbidden, forbidden */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "automations.placeholders": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The placeholders */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        namespaces: {
                            /** @description What the namespace holds. */
                            description: string;
                            namespace: string;
                            /** @description Its placeholders; none for `actions`, whose `{actions.<step>.id}` names an earlier step by its id. */
                            placeholders: {
                                /** @description Whether a firing can leave it empty: give it a fallback, `{order.reference ?? "none"}`. */
                                canBeEmpty: boolean;
                                /** @description What it holds. */
                                description: string;
                                /** @description Personal data: written only in an action bound for the order's own printshop. */
                                personal: boolean;
                                /** @description The placeholder as a text writes it: `{order.id}`. */
                                token: string;
                            }[];
                        }[];
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "automations.testRun": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description A saved automation, by its id. Name it or `draft`. */
                    automationId?: string;
                    /** @description A draft, as the editor holds it. Name it or `automationId`. */
                    draft?: {
                        /** @description The automation's tree of steps. */
                        body: {
                            /** @description When its steps run: conditions on the subject, combined with `all`, `any` and `not`. Left out, whenever the trigger happens in its sources. */
                            conditions?: {
                                /** @description Every one holds. */
                                all: unknown[];
                            } | {
                                /** @description At least one holds. */
                                any: unknown[];
                            } | {
                                /** @description It does not hold. */
                                not?: unknown;
                            } | {
                                /**
                                 * @description The fact compared.
                                 * @enum {string}
                                 */
                                field: "origin" | "template" | "tag" | "category" | "blank" | "variant" | "printshop" | "order_status" | "failure_kind" | "delivery_outcome" | "caused_by_automation";
                                /** @description It holds when the fact is one of these: each at most 200 characters, or 2054 for an origin, which may name a store's site. */
                                in: string[];
                            } | {
                                /** @description It holds from this many copies up. */
                                atLeast?: number;
                                /** @description It holds up to this many copies. */
                                atMost?: number;
                                /**
                                 * @description The order's quantity.
                                 * @enum {string}
                                 */
                                field: "quantity";
                            } | {
                                /**
                                 * @description The order's delivery address.
                                 * @enum {string}
                                 */
                                field: "delivery_address";
                                /** @description Whether it must be set, or must not. */
                                present: boolean;
                            };
                            /** @description The steps, in the order they run. A step's `type` names an action from the catalogue. */
                            steps: {
                                /** @description Further steps, under each branch's name. */
                                branches?: {
                                    [key: string]: unknown[];
                                };
                                /** @description Its id, unique in the body: what a firing names it by. */
                                id: string;
                                /**
                                 * @description What its type takes; the draft check refuses settings the type does not.
                                 * @default {}
                                 */
                                settings?: {
                                    [key: string]: unknown;
                                };
                                /** @description Its action (approve, create_print, place_order, reroute, cancel_order, notify, email, webhook) or flow step (only_if, paths, wait_for, delay). */
                                type: string;
                            }[];
                        };
                        /**
                         * @description `author`: it acts with the grants of the member who last saved it. `workspace`: it acts as the workspace, tied to no member; only an admin may set it, and an automation made with a secret key always runs so.
                         * @default author
                         * @enum {string}
                         */
                        runsAs?: "author" | "workspace";
                        /** @description The sources it acts on: the studio always; designer links, keys and connected stores, each every one or a snapshot. To act on only some, an Only if compares the design's `origin`. */
                        sources?: {
                            /** @description On, it acts on designs from every secret and publishable key no store was given, those added later too. Off, only from those in `keys`. */
                            includeNewKeys: boolean;
                            /** @description On, it acts on designs from every designer link, those made later too. Off, only from the links in `links`. */
                            includeNewLinks: boolean;
                            /** @description On, it acts on designs from every connected store, those connected later too. Off, only from those in `stores`. A store may have its own automated flows on its designs; if it does, the first to move one on wins. */
                            includeNewStores: boolean;
                            /** @description While its switch is off, those that existed when it was switched off; null while it is on. A save that turns it off with none takes it then. */
                            keys?: {
                                /** @description Each one that existed then, as a design's origin names it: `link:<id>`, `secret_key:<id>` and `publishable_key:<id>`, or `store:<site>`. */
                                sources: string[];
                                /** @description When its switch was turned off: the snapshot is as of then. */
                                takenAt: number;
                            } | null;
                            /** @description While its switch is off, those that existed when it was switched off; null while it is on. A save that turns it off with none takes it then. */
                            links?: {
                                /** @description Each one that existed then, as a design's origin names it: `link:<id>`, `secret_key:<id>` and `publishable_key:<id>`, or `store:<site>`. */
                                sources: string[];
                                /** @description When its switch was turned off: the snapshot is as of then. */
                                takenAt: number;
                            } | null;
                            /** @description While its switch is off, those that existed when it was switched off; null while it is on. A save that turns it off with none takes it then. */
                            stores?: {
                                /** @description Each one that existed then, as a design's origin names it: `link:<id>`, `secret_key:<id>` and `publishable_key:<id>`, or `store:<site>`. */
                                sources: string[];
                                /** @description When its switch was turned off: the snapshot is as of then. */
                                takenAt: number;
                            } | null;
                        };
                        /**
                         * @description Spend actions it may take per rolling 24 hours.
                         * @default 50
                         */
                        spendLimit?: number;
                        /**
                         * @description The event it fires on; null for none yet, which fires on nothing. One with none cannot be enabled.
                         * @enum {string|null}
                         */
                        trigger: "design.committed" | "design.approved" | "design.changes_requested" | "design.delivery_captured" | "print.completed" | "print.failed" | "order.submitted" | "order.status_changed" | "order.failed" | "order.cancelled" | "order.delivery_changed" | null;
                    };
                    /** @description The past event to test on, as the events found name it. */
                    eventId: string;
                };
            };
        };
        responses: {
            /** @description What it would have done */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Its conditions, each with the values compared; null for none. */
                        conditions: {
                            holds: boolean;
                            leaves: {
                                field: string;
                                /** @description What the subject has, compared. */
                                has: string[] | number | boolean | null;
                                holds: boolean;
                                /** @description Where it sits in the tree, as `all.0.not`; empty for a tree of one. */
                                path: string;
                                wants: {
                                    [key: string]: unknown;
                                };
                            }[];
                        } | null;
                        event: {
                            at: number;
                            id: string;
                            type: string;
                        };
                        /** @description Whether the automation would fire on it. */
                        fires: boolean;
                        /** @description Why it would not fire. */
                        reason: string | null;
                        /** @description Every step, in order, branches after their step: what it would do. */
                        steps: {
                            branch: string[];
                            label: string | null;
                            outcome: string;
                            /** @description The printshop it would act at, and what it could do. */
                            printshops: ({
                                /** @enum {string} */
                                can: "yes";
                                id: string;
                                name: string;
                            } | {
                                /** @enum {string} */
                                can: "no";
                                id: string;
                                name: string;
                                /** @description Why it cannot act there. */
                                reason: string;
                            } | {
                                /** @enum {string} */
                                can: "conditional";
                                id: string;
                                name: string;
                                /** @description When it can: checked when it runs, and a step that meets it unmet is blocked. */
                                rule: string;
                            })[];
                            /** @description Why it is blocked, would pause or would stop; what a wait or a delay would wait for; the path a choice of paths would take. */
                            reason: string | null;
                            /** @description Its placeholders as they render for this event. Empty for an MCP key: a text written to an order's own printshop may name its customer. */
                            rendered: {
                                [key: string]: string;
                            };
                            /** @description The limits a spend action counts against, as they would stand when it ran. */
                            spend: {
                                automation: {
                                    limit: number;
                                    used: number;
                                };
                                workspace: {
                                    ceiling: number;
                                    used: number;
                                };
                            } | null;
                            stepId: string;
                            type: string;
                        }[];
                        /** @description What it was about, by id. */
                        subject: {
                            designId?: string;
                            orderId?: string;
                            printId?: string;
                            revision?: number;
                        } | null;
                    };
                };
            };
            /** @description Refused: invalid_body */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `invalid_body`. */
                        fields?: string[];
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: feature_disabled, origin_forbidden, forbidden */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: automation_not_found, event_not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "automations.testRunEvents": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description A saved automation, by its id. Name it or `draft`. */
                    automationId?: string;
                    /** @description A draft, as the editor holds it. Name it or `automationId`. */
                    draft?: {
                        /** @description The automation's tree of steps. */
                        body: {
                            /** @description When its steps run: conditions on the subject, combined with `all`, `any` and `not`. Left out, whenever the trigger happens in its sources. */
                            conditions?: {
                                /** @description Every one holds. */
                                all: unknown[];
                            } | {
                                /** @description At least one holds. */
                                any: unknown[];
                            } | {
                                /** @description It does not hold. */
                                not?: unknown;
                            } | {
                                /**
                                 * @description The fact compared.
                                 * @enum {string}
                                 */
                                field: "origin" | "template" | "tag" | "category" | "blank" | "variant" | "printshop" | "order_status" | "failure_kind" | "delivery_outcome" | "caused_by_automation";
                                /** @description It holds when the fact is one of these: each at most 200 characters, or 2054 for an origin, which may name a store's site. */
                                in: string[];
                            } | {
                                /** @description It holds from this many copies up. */
                                atLeast?: number;
                                /** @description It holds up to this many copies. */
                                atMost?: number;
                                /**
                                 * @description The order's quantity.
                                 * @enum {string}
                                 */
                                field: "quantity";
                            } | {
                                /**
                                 * @description The order's delivery address.
                                 * @enum {string}
                                 */
                                field: "delivery_address";
                                /** @description Whether it must be set, or must not. */
                                present: boolean;
                            };
                            /** @description The steps, in the order they run. A step's `type` names an action from the catalogue. */
                            steps: {
                                /** @description Further steps, under each branch's name. */
                                branches?: {
                                    [key: string]: unknown[];
                                };
                                /** @description Its id, unique in the body: what a firing names it by. */
                                id: string;
                                /**
                                 * @description What its type takes; the draft check refuses settings the type does not.
                                 * @default {}
                                 */
                                settings?: {
                                    [key: string]: unknown;
                                };
                                /** @description Its action (approve, create_print, place_order, reroute, cancel_order, notify, email, webhook) or flow step (only_if, paths, wait_for, delay). */
                                type: string;
                            }[];
                        };
                        /**
                         * @description `author`: it acts with the grants of the member who last saved it. `workspace`: it acts as the workspace, tied to no member; only an admin may set it, and an automation made with a secret key always runs so.
                         * @default author
                         * @enum {string}
                         */
                        runsAs?: "author" | "workspace";
                        /** @description The sources it acts on: the studio always; designer links, keys and connected stores, each every one or a snapshot. To act on only some, an Only if compares the design's `origin`. */
                        sources?: {
                            /** @description On, it acts on designs from every secret and publishable key no store was given, those added later too. Off, only from those in `keys`. */
                            includeNewKeys: boolean;
                            /** @description On, it acts on designs from every designer link, those made later too. Off, only from the links in `links`. */
                            includeNewLinks: boolean;
                            /** @description On, it acts on designs from every connected store, those connected later too. Off, only from those in `stores`. A store may have its own automated flows on its designs; if it does, the first to move one on wins. */
                            includeNewStores: boolean;
                            /** @description While its switch is off, those that existed when it was switched off; null while it is on. A save that turns it off with none takes it then. */
                            keys?: {
                                /** @description Each one that existed then, as a design's origin names it: `link:<id>`, `secret_key:<id>` and `publishable_key:<id>`, or `store:<site>`. */
                                sources: string[];
                                /** @description When its switch was turned off: the snapshot is as of then. */
                                takenAt: number;
                            } | null;
                            /** @description While its switch is off, those that existed when it was switched off; null while it is on. A save that turns it off with none takes it then. */
                            links?: {
                                /** @description Each one that existed then, as a design's origin names it: `link:<id>`, `secret_key:<id>` and `publishable_key:<id>`, or `store:<site>`. */
                                sources: string[];
                                /** @description When its switch was turned off: the snapshot is as of then. */
                                takenAt: number;
                            } | null;
                            /** @description While its switch is off, those that existed when it was switched off; null while it is on. A save that turns it off with none takes it then. */
                            stores?: {
                                /** @description Each one that existed then, as a design's origin names it: `link:<id>`, `secret_key:<id>` and `publishable_key:<id>`, or `store:<site>`. */
                                sources: string[];
                                /** @description When its switch was turned off: the snapshot is as of then. */
                                takenAt: number;
                            } | null;
                        };
                        /**
                         * @description Spend actions it may take per rolling 24 hours.
                         * @default 50
                         */
                        spendLimit?: number;
                        /**
                         * @description The event it fires on; null for none yet, which fires on nothing. One with none cannot be enabled.
                         * @enum {string|null}
                         */
                        trigger: "design.committed" | "design.approved" | "design.changes_requested" | "design.delivery_captured" | "print.completed" | "print.failed" | "order.submitted" | "order.status_changed" | "order.failed" | "order.cancelled" | "order.delivery_changed" | null;
                    };
                    /** @description One event by its id, among older ones than the newest 20. */
                    eventId?: string;
                };
            };
        };
        responses: {
            /** @description The events, newest first */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        events: {
                            at: number;
                            id: string;
                            subject: {
                                designId?: string;
                                orderId?: string;
                                printId?: string;
                                revision?: number;
                            };
                            type: string;
                        }[];
                    };
                };
            };
            /** @description Refused: invalid_body */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `invalid_body`. */
                        fields?: string[];
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: feature_disabled, origin_forbidden, forbidden */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: automation_not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "automations.get": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The automation */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description The member whose grants it acts with: whoever last saved it. Null when it runs as the workspace. */
                        author: {
                            name: string | null;
                            userId: string;
                        } | null;
                        /** @description The automation's tree of steps. */
                        body: {
                            /** @description When its steps run: conditions on the subject, combined with `all`, `any` and `not`. Left out, whenever the trigger happens in its sources. */
                            conditions?: {
                                /** @description Every one holds. */
                                all: unknown[];
                            } | {
                                /** @description At least one holds. */
                                any: unknown[];
                            } | {
                                /** @description It does not hold. */
                                not?: unknown;
                            } | {
                                /** @description The fact compared. */
                                field: string;
                                /** @description It holds when the fact is one of these: each at most 200 characters, or 2054 for an origin, which may name a store's site. */
                                in: string[];
                            } | {
                                /** @description It holds from this many copies up. */
                                atLeast?: number;
                                /** @description It holds up to this many copies. */
                                atMost?: number;
                                /**
                                 * @description The order's quantity.
                                 * @enum {string}
                                 */
                                field: "quantity";
                            } | {
                                /**
                                 * @description The order's delivery address.
                                 * @enum {string}
                                 */
                                field: "delivery_address";
                                /** @description Whether it must be set, or must not. */
                                present: boolean;
                            };
                            /** @description The steps, in the order they run. A step's `type` names an action from the catalogue. */
                            steps: {
                                /** @description Further steps, under each branch's name. */
                                branches?: {
                                    [key: string]: unknown[];
                                };
                                /** @description Its id, unique in the body: what a firing names it by. */
                                id: string;
                                /**
                                 * @description What its type takes; the draft check refuses settings the type does not.
                                 * @default {}
                                 */
                                settings: {
                                    [key: string]: unknown;
                                };
                                /** @description Its action (approve, create_print, place_order, reroute, cancel_order, notify, email, webhook) or flow step (only_if, paths, wait_for, delay). */
                                type: string;
                            }[];
                        };
                        createdAt: number;
                        enabled: boolean;
                        /** @description When it was last enabled: it never fires on an event from before. Null for one never enabled. */
                        enabledAt: number | null;
                        firings: {
                            count: number;
                            lastAt: number | null;
                            paused: number;
                            /** @description Spend actions it took in the last 24 hours, against its spend limit. */
                            spentToday: number;
                            waiting: number;
                        };
                        id: string;
                        name: string;
                        runsAs: string;
                        /** @description The sources it acts on: the studio always; designer links, keys and connected stores, each every one or a snapshot. To act on only some, an Only if compares the design's `origin`. */
                        sources: {
                            /** @description On, it acts on designs from every secret and publishable key no store was given, those added later too. Off, only from those in `keys`. */
                            includeNewKeys: boolean;
                            /** @description On, it acts on designs from every designer link, those made later too. Off, only from the links in `links`. */
                            includeNewLinks: boolean;
                            /** @description On, it acts on designs from every connected store, those connected later too. Off, only from those in `stores`. A store may have its own automated flows on its designs; if it does, the first to move one on wins. */
                            includeNewStores: boolean;
                            /** @description While its switch is off, those that existed when it was switched off; null while it is on. A save that turns it off with none takes it then. */
                            keys: {
                                /** @description Each one that existed then, as a design's origin names it: `link:<id>`, `secret_key:<id>` and `publishable_key:<id>`, or `store:<site>`. */
                                sources: string[];
                                /** @description When its switch was turned off: the snapshot is as of then. */
                                takenAt: number;
                            } | null;
                            /** @description While its switch is off, those that existed when it was switched off; null while it is on. A save that turns it off with none takes it then. */
                            links: {
                                /** @description Each one that existed then, as a design's origin names it: `link:<id>`, `secret_key:<id>` and `publishable_key:<id>`, or `store:<site>`. */
                                sources: string[];
                                /** @description When its switch was turned off: the snapshot is as of then. */
                                takenAt: number;
                            } | null;
                            /** @description While its switch is off, those that existed when it was switched off; null while it is on. A save that turns it off with none takes it then. */
                            stores: {
                                /** @description Each one that existed then, as a design's origin names it: `link:<id>`, `secret_key:<id>` and `publishable_key:<id>`, or `store:<site>`. */
                                sources: string[];
                                /** @description When its switch was turned off: the snapshot is as of then. */
                                takenAt: number;
                            } | null;
                        };
                        spendLimit: number;
                        /** @description Where it stands: `enabled` or `disabled`; `failing` while its latest firing failed; `broken` while it cannot fire at all, because its author lacks a grant it needs. `reason` says why, in words. */
                        standing: {
                            state: string;
                        } | {
                            reason: string;
                            /** @enum {string} */
                            state: "failing";
                        } | {
                            code: string;
                            reason: string;
                            /** @enum {string} */
                            state: "broken";
                        };
                        /** @description The event it fires on; null for none yet. */
                        trigger: string | null;
                        /** @description When it was last saved: a save names it as `expectedUpdatedAt`. */
                        updatedAt: number;
                        /** @description Its current version. */
                        version: number;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: automation_not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "automations.save": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description The automation's tree of steps. */
                    body: {
                        /** @description When its steps run: conditions on the subject, combined with `all`, `any` and `not`. Left out, whenever the trigger happens in its sources. */
                        conditions?: {
                            /** @description Every one holds. */
                            all: unknown[];
                        } | {
                            /** @description At least one holds. */
                            any: unknown[];
                        } | {
                            /** @description It does not hold. */
                            not?: unknown;
                        } | {
                            /**
                             * @description The fact compared.
                             * @enum {string}
                             */
                            field: "origin" | "template" | "tag" | "category" | "blank" | "variant" | "printshop" | "order_status" | "failure_kind" | "delivery_outcome" | "caused_by_automation";
                            /** @description It holds when the fact is one of these: each at most 200 characters, or 2054 for an origin, which may name a store's site. */
                            in: string[];
                        } | {
                            /** @description It holds from this many copies up. */
                            atLeast?: number;
                            /** @description It holds up to this many copies. */
                            atMost?: number;
                            /**
                             * @description The order's quantity.
                             * @enum {string}
                             */
                            field: "quantity";
                        } | {
                            /**
                             * @description The order's delivery address.
                             * @enum {string}
                             */
                            field: "delivery_address";
                            /** @description Whether it must be set, or must not. */
                            present: boolean;
                        };
                        /** @description The steps, in the order they run. A step's `type` names an action from the catalogue. */
                        steps: {
                            /** @description Further steps, under each branch's name. */
                            branches?: {
                                [key: string]: unknown[];
                            };
                            /** @description Its id, unique in the body: what a firing names it by. */
                            id: string;
                            /**
                             * @description What its type takes; the draft check refuses settings the type does not.
                             * @default {}
                             */
                            settings?: {
                                [key: string]: unknown;
                            };
                            /** @description Its action (approve, create_print, place_order, reroute, cancel_order, notify, email, webhook) or flow step (only_if, paths, wait_for, delay). */
                            type: string;
                        }[];
                    };
                    /** @description Confirms that the automation spends without a person, at most its spend limit in 24 hours. Required, true, when it holds a spend action (create print, place order, reroute); a save without it is refused `spend_unconfirmed`. */
                    confirmSpend?: boolean;
                    /**
                     * @description Save only while it is disabled: an enabled one is refused `automation_enabled` and left as it is.
                     * @enum {boolean}
                     */
                    expectDisabled?: true;
                    /** @description The `updatedAt` the draft was read at. A save since is refused `automation_changed`, naming who saved it and when. */
                    expectedUpdatedAt: number;
                    /** @description What members call it. */
                    name: string;
                    /**
                     * @description `author`: it acts with the grants of the member who last saved it. `workspace`: it acts as the workspace, tied to no member; only an admin may set it, and an automation made with a secret key always runs so.
                     * @enum {string}
                     */
                    runsAs: "author" | "workspace";
                    /** @description The sources it acts on: the studio always; designer links, keys and connected stores, each every one or a snapshot. To act on only some, an Only if compares the design's `origin`. */
                    sources: {
                        /** @description On, it acts on designs from every secret and publishable key no store was given, those added later too. Off, only from those in `keys`. */
                        includeNewKeys: boolean;
                        /** @description On, it acts on designs from every designer link, those made later too. Off, only from the links in `links`. */
                        includeNewLinks: boolean;
                        /** @description On, it acts on designs from every connected store, those connected later too. Off, only from those in `stores`. A store may have its own automated flows on its designs; if it does, the first to move one on wins. */
                        includeNewStores: boolean;
                        /** @description While its switch is off, those that existed when it was switched off; null while it is on. A save that turns it off with none takes it then. */
                        keys?: {
                            /** @description Each one that existed then, as a design's origin names it: `link:<id>`, `secret_key:<id>` and `publishable_key:<id>`, or `store:<site>`. */
                            sources: string[];
                            /** @description When its switch was turned off: the snapshot is as of then. */
                            takenAt: number;
                        } | null;
                        /** @description While its switch is off, those that existed when it was switched off; null while it is on. A save that turns it off with none takes it then. */
                        links?: {
                            /** @description Each one that existed then, as a design's origin names it: `link:<id>`, `secret_key:<id>` and `publishable_key:<id>`, or `store:<site>`. */
                            sources: string[];
                            /** @description When its switch was turned off: the snapshot is as of then. */
                            takenAt: number;
                        } | null;
                        /** @description While its switch is off, those that existed when it was switched off; null while it is on. A save that turns it off with none takes it then. */
                        stores?: {
                            /** @description Each one that existed then, as a design's origin names it: `link:<id>`, `secret_key:<id>` and `publishable_key:<id>`, or `store:<site>`. */
                            sources: string[];
                            /** @description When its switch was turned off: the snapshot is as of then. */
                            takenAt: number;
                        } | null;
                    };
                    /** @description Spend actions it may take per rolling 24 hours. */
                    spendLimit: number;
                    /**
                     * @description The event it fires on; null for none yet, which fires on nothing. One with none cannot be enabled.
                     * @enum {string|null}
                     */
                    trigger: "design.committed" | "design.approved" | "design.changes_requested" | "design.delivery_captured" | "print.completed" | "print.failed" | "order.submitted" | "order.status_changed" | "order.failed" | "order.cancelled" | "order.delivery_changed" | null;
                };
            };
        };
        responses: {
            /** @description The automation as saved */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description The member whose grants it acts with: whoever last saved it. Null when it runs as the workspace. */
                        author: {
                            name: string | null;
                            userId: string;
                        } | null;
                        /** @description The automation's tree of steps. */
                        body: {
                            /** @description When its steps run: conditions on the subject, combined with `all`, `any` and `not`. Left out, whenever the trigger happens in its sources. */
                            conditions?: {
                                /** @description Every one holds. */
                                all: unknown[];
                            } | {
                                /** @description At least one holds. */
                                any: unknown[];
                            } | {
                                /** @description It does not hold. */
                                not?: unknown;
                            } | {
                                /** @description The fact compared. */
                                field: string;
                                /** @description It holds when the fact is one of these: each at most 200 characters, or 2054 for an origin, which may name a store's site. */
                                in: string[];
                            } | {
                                /** @description It holds from this many copies up. */
                                atLeast?: number;
                                /** @description It holds up to this many copies. */
                                atMost?: number;
                                /**
                                 * @description The order's quantity.
                                 * @enum {string}
                                 */
                                field: "quantity";
                            } | {
                                /**
                                 * @description The order's delivery address.
                                 * @enum {string}
                                 */
                                field: "delivery_address";
                                /** @description Whether it must be set, or must not. */
                                present: boolean;
                            };
                            /** @description The steps, in the order they run. A step's `type` names an action from the catalogue. */
                            steps: {
                                /** @description Further steps, under each branch's name. */
                                branches?: {
                                    [key: string]: unknown[];
                                };
                                /** @description Its id, unique in the body: what a firing names it by. */
                                id: string;
                                /**
                                 * @description What its type takes; the draft check refuses settings the type does not.
                                 * @default {}
                                 */
                                settings: {
                                    [key: string]: unknown;
                                };
                                /** @description Its action (approve, create_print, place_order, reroute, cancel_order, notify, email, webhook) or flow step (only_if, paths, wait_for, delay). */
                                type: string;
                            }[];
                        };
                        createdAt: number;
                        enabled: boolean;
                        /** @description When it was last enabled: it never fires on an event from before. Null for one never enabled. */
                        enabledAt: number | null;
                        firings: {
                            count: number;
                            lastAt: number | null;
                            paused: number;
                            /** @description Spend actions it took in the last 24 hours, against its spend limit. */
                            spentToday: number;
                            waiting: number;
                        };
                        id: string;
                        name: string;
                        runsAs: string;
                        /** @description The sources it acts on: the studio always; designer links, keys and connected stores, each every one or a snapshot. To act on only some, an Only if compares the design's `origin`. */
                        sources: {
                            /** @description On, it acts on designs from every secret and publishable key no store was given, those added later too. Off, only from those in `keys`. */
                            includeNewKeys: boolean;
                            /** @description On, it acts on designs from every designer link, those made later too. Off, only from the links in `links`. */
                            includeNewLinks: boolean;
                            /** @description On, it acts on designs from every connected store, those connected later too. Off, only from those in `stores`. A store may have its own automated flows on its designs; if it does, the first to move one on wins. */
                            includeNewStores: boolean;
                            /** @description While its switch is off, those that existed when it was switched off; null while it is on. A save that turns it off with none takes it then. */
                            keys: {
                                /** @description Each one that existed then, as a design's origin names it: `link:<id>`, `secret_key:<id>` and `publishable_key:<id>`, or `store:<site>`. */
                                sources: string[];
                                /** @description When its switch was turned off: the snapshot is as of then. */
                                takenAt: number;
                            } | null;
                            /** @description While its switch is off, those that existed when it was switched off; null while it is on. A save that turns it off with none takes it then. */
                            links: {
                                /** @description Each one that existed then, as a design's origin names it: `link:<id>`, `secret_key:<id>` and `publishable_key:<id>`, or `store:<site>`. */
                                sources: string[];
                                /** @description When its switch was turned off: the snapshot is as of then. */
                                takenAt: number;
                            } | null;
                            /** @description While its switch is off, those that existed when it was switched off; null while it is on. A save that turns it off with none takes it then. */
                            stores: {
                                /** @description Each one that existed then, as a design's origin names it: `link:<id>`, `secret_key:<id>` and `publishable_key:<id>`, or `store:<site>`. */
                                sources: string[];
                                /** @description When its switch was turned off: the snapshot is as of then. */
                                takenAt: number;
                            } | null;
                        };
                        spendLimit: number;
                        /** @description Where it stands: `enabled` or `disabled`; `failing` while its latest firing failed; `broken` while it cannot fire at all, because its author lacks a grant it needs. `reason` says why, in words. */
                        standing: {
                            state: string;
                        } | {
                            reason: string;
                            /** @enum {string} */
                            state: "failing";
                        } | {
                            code: string;
                            reason: string;
                            /** @enum {string} */
                            state: "broken";
                        };
                        /** @description The event it fires on; null for none yet. */
                        trigger: string | null;
                        /** @description When it was last saved: a save names it as `expectedUpdatedAt`. */
                        updatedAt: number;
                        /** @description Its current version. */
                        version: number;
                    };
                };
            };
            /** @description Refused: invalid_body */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `invalid_body`. */
                        fields?: string[];
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: feature_disabled, admin_only, origin_forbidden, forbidden */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                        /** @description Always sent with `admin_only`. */
                        reason?: string;
                    };
                };
            };
            /** @description Refused: automation_not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: automation_changed, automation_no_trigger, automation_enabled */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `automation_no_trigger`, `automation_enabled`. */
                        reason?: string;
                        /** @description Always sent with `automation_changed`. */
                        savedAt?: number;
                        /** @description Who saved it: a member, or a secret key by the label it had then. Always sent with `automation_changed`. */
                        savedBy?: {
                            /** @enum {string} */
                            kind: "member";
                            name: string | null;
                            userId: string;
                        } | {
                            /** @enum {string} */
                            kind: "key";
                            label: string;
                        };
                    };
                };
            };
            /** @description Refused: author_needs_member, draft_refused, spend_unconfirmed, spend_limit_over_ceiling, payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Sent with `payload_too_large`. */
                        bytes?: number;
                        /** @description The workspace's ceiling, the most a spend limit may say. Always sent with `spend_limit_over_ceiling`. */
                        ceiling?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                        /** @description Always sent with `author_needs_member`, `spend_unconfirmed`, `spend_limit_over_ceiling`. */
                        reason?: string;
                        /** @description Always sent with `draft_refused`. */
                        refusals?: {
                            code: string;
                            /** @description What is wrong, in words. */
                            message: string;
                            /** @description The step it is about. */
                            stepId?: string;
                        }[];
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "automations.delete": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description What deleting it cancelled */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description How many of its unfinished firings were cancelled. */
                        cancelledFirings: number;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: feature_disabled, admin_only, origin_forbidden, forbidden */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                        /** @description Always sent with `admin_only`. */
                        reason?: string;
                    };
                };
            };
            /** @description Refused: automation_not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "automations.disable": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The automation, and what disabling it cancelled */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        automation: {
                            /** @description The member whose grants it acts with: whoever last saved it. Null when it runs as the workspace. */
                            author: {
                                name: string | null;
                                userId: string;
                            } | null;
                            /** @description The automation's tree of steps. */
                            body: {
                                /** @description When its steps run: conditions on the subject, combined with `all`, `any` and `not`. Left out, whenever the trigger happens in its sources. */
                                conditions?: {
                                    /** @description Every one holds. */
                                    all: unknown[];
                                } | {
                                    /** @description At least one holds. */
                                    any: unknown[];
                                } | {
                                    /** @description It does not hold. */
                                    not?: unknown;
                                } | {
                                    /** @description The fact compared. */
                                    field: string;
                                    /** @description It holds when the fact is one of these: each at most 200 characters, or 2054 for an origin, which may name a store's site. */
                                    in: string[];
                                } | {
                                    /** @description It holds from this many copies up. */
                                    atLeast?: number;
                                    /** @description It holds up to this many copies. */
                                    atMost?: number;
                                    /**
                                     * @description The order's quantity.
                                     * @enum {string}
                                     */
                                    field: "quantity";
                                } | {
                                    /**
                                     * @description The order's delivery address.
                                     * @enum {string}
                                     */
                                    field: "delivery_address";
                                    /** @description Whether it must be set, or must not. */
                                    present: boolean;
                                };
                                /** @description The steps, in the order they run. A step's `type` names an action from the catalogue. */
                                steps: {
                                    /** @description Further steps, under each branch's name. */
                                    branches?: {
                                        [key: string]: unknown[];
                                    };
                                    /** @description Its id, unique in the body: what a firing names it by. */
                                    id: string;
                                    /**
                                     * @description What its type takes; the draft check refuses settings the type does not.
                                     * @default {}
                                     */
                                    settings: {
                                        [key: string]: unknown;
                                    };
                                    /** @description Its action (approve, create_print, place_order, reroute, cancel_order, notify, email, webhook) or flow step (only_if, paths, wait_for, delay). */
                                    type: string;
                                }[];
                            };
                            createdAt: number;
                            enabled: boolean;
                            /** @description When it was last enabled: it never fires on an event from before. Null for one never enabled. */
                            enabledAt: number | null;
                            firings: {
                                count: number;
                                lastAt: number | null;
                                paused: number;
                                /** @description Spend actions it took in the last 24 hours, against its spend limit. */
                                spentToday: number;
                                waiting: number;
                            };
                            id: string;
                            name: string;
                            runsAs: string;
                            /** @description The sources it acts on: the studio always; designer links, keys and connected stores, each every one or a snapshot. To act on only some, an Only if compares the design's `origin`. */
                            sources: {
                                /** @description On, it acts on designs from every secret and publishable key no store was given, those added later too. Off, only from those in `keys`. */
                                includeNewKeys: boolean;
                                /** @description On, it acts on designs from every designer link, those made later too. Off, only from the links in `links`. */
                                includeNewLinks: boolean;
                                /** @description On, it acts on designs from every connected store, those connected later too. Off, only from those in `stores`. A store may have its own automated flows on its designs; if it does, the first to move one on wins. */
                                includeNewStores: boolean;
                                /** @description While its switch is off, those that existed when it was switched off; null while it is on. A save that turns it off with none takes it then. */
                                keys: {
                                    /** @description Each one that existed then, as a design's origin names it: `link:<id>`, `secret_key:<id>` and `publishable_key:<id>`, or `store:<site>`. */
                                    sources: string[];
                                    /** @description When its switch was turned off: the snapshot is as of then. */
                                    takenAt: number;
                                } | null;
                                /** @description While its switch is off, those that existed when it was switched off; null while it is on. A save that turns it off with none takes it then. */
                                links: {
                                    /** @description Each one that existed then, as a design's origin names it: `link:<id>`, `secret_key:<id>` and `publishable_key:<id>`, or `store:<site>`. */
                                    sources: string[];
                                    /** @description When its switch was turned off: the snapshot is as of then. */
                                    takenAt: number;
                                } | null;
                                /** @description While its switch is off, those that existed when it was switched off; null while it is on. A save that turns it off with none takes it then. */
                                stores: {
                                    /** @description Each one that existed then, as a design's origin names it: `link:<id>`, `secret_key:<id>` and `publishable_key:<id>`, or `store:<site>`. */
                                    sources: string[];
                                    /** @description When its switch was turned off: the snapshot is as of then. */
                                    takenAt: number;
                                } | null;
                            };
                            spendLimit: number;
                            /** @description Where it stands: `enabled` or `disabled`; `failing` while its latest firing failed; `broken` while it cannot fire at all, because its author lacks a grant it needs. `reason` says why, in words. */
                            standing: {
                                state: string;
                            } | {
                                reason: string;
                                /** @enum {string} */
                                state: "failing";
                            } | {
                                code: string;
                                reason: string;
                                /** @enum {string} */
                                state: "broken";
                            };
                            /** @description The event it fires on; null for none yet. */
                            trigger: string | null;
                            /** @description When it was last saved: a save names it as `expectedUpdatedAt`. */
                            updatedAt: number;
                            /** @description Its current version. */
                            version: number;
                        };
                        /** @description How many of its waiting firings disabling it cancelled. */
                        cancelledFirings: number;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: feature_disabled, admin_only, origin_forbidden, forbidden */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                        /** @description Always sent with `admin_only`. */
                        reason?: string;
                    };
                };
            };
            /** @description Refused: automation_not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "automations.duplicate": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The copy */
            201: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description The member whose grants it acts with: whoever last saved it. Null when it runs as the workspace. */
                        author: {
                            name: string | null;
                            userId: string;
                        } | null;
                        /** @description The automation's tree of steps. */
                        body: {
                            /** @description When its steps run: conditions on the subject, combined with `all`, `any` and `not`. Left out, whenever the trigger happens in its sources. */
                            conditions?: {
                                /** @description Every one holds. */
                                all: unknown[];
                            } | {
                                /** @description At least one holds. */
                                any: unknown[];
                            } | {
                                /** @description It does not hold. */
                                not?: unknown;
                            } | {
                                /** @description The fact compared. */
                                field: string;
                                /** @description It holds when the fact is one of these: each at most 200 characters, or 2054 for an origin, which may name a store's site. */
                                in: string[];
                            } | {
                                /** @description It holds from this many copies up. */
                                atLeast?: number;
                                /** @description It holds up to this many copies. */
                                atMost?: number;
                                /**
                                 * @description The order's quantity.
                                 * @enum {string}
                                 */
                                field: "quantity";
                            } | {
                                /**
                                 * @description The order's delivery address.
                                 * @enum {string}
                                 */
                                field: "delivery_address";
                                /** @description Whether it must be set, or must not. */
                                present: boolean;
                            };
                            /** @description The steps, in the order they run. A step's `type` names an action from the catalogue. */
                            steps: {
                                /** @description Further steps, under each branch's name. */
                                branches?: {
                                    [key: string]: unknown[];
                                };
                                /** @description Its id, unique in the body: what a firing names it by. */
                                id: string;
                                /**
                                 * @description What its type takes; the draft check refuses settings the type does not.
                                 * @default {}
                                 */
                                settings: {
                                    [key: string]: unknown;
                                };
                                /** @description Its action (approve, create_print, place_order, reroute, cancel_order, notify, email, webhook) or flow step (only_if, paths, wait_for, delay). */
                                type: string;
                            }[];
                        };
                        createdAt: number;
                        enabled: boolean;
                        /** @description When it was last enabled: it never fires on an event from before. Null for one never enabled. */
                        enabledAt: number | null;
                        firings: {
                            count: number;
                            lastAt: number | null;
                            paused: number;
                            /** @description Spend actions it took in the last 24 hours, against its spend limit. */
                            spentToday: number;
                            waiting: number;
                        };
                        id: string;
                        name: string;
                        runsAs: string;
                        /** @description The sources it acts on: the studio always; designer links, keys and connected stores, each every one or a snapshot. To act on only some, an Only if compares the design's `origin`. */
                        sources: {
                            /** @description On, it acts on designs from every secret and publishable key no store was given, those added later too. Off, only from those in `keys`. */
                            includeNewKeys: boolean;
                            /** @description On, it acts on designs from every designer link, those made later too. Off, only from the links in `links`. */
                            includeNewLinks: boolean;
                            /** @description On, it acts on designs from every connected store, those connected later too. Off, only from those in `stores`. A store may have its own automated flows on its designs; if it does, the first to move one on wins. */
                            includeNewStores: boolean;
                            /** @description While its switch is off, those that existed when it was switched off; null while it is on. A save that turns it off with none takes it then. */
                            keys: {
                                /** @description Each one that existed then, as a design's origin names it: `link:<id>`, `secret_key:<id>` and `publishable_key:<id>`, or `store:<site>`. */
                                sources: string[];
                                /** @description When its switch was turned off: the snapshot is as of then. */
                                takenAt: number;
                            } | null;
                            /** @description While its switch is off, those that existed when it was switched off; null while it is on. A save that turns it off with none takes it then. */
                            links: {
                                /** @description Each one that existed then, as a design's origin names it: `link:<id>`, `secret_key:<id>` and `publishable_key:<id>`, or `store:<site>`. */
                                sources: string[];
                                /** @description When its switch was turned off: the snapshot is as of then. */
                                takenAt: number;
                            } | null;
                            /** @description While its switch is off, those that existed when it was switched off; null while it is on. A save that turns it off with none takes it then. */
                            stores: {
                                /** @description Each one that existed then, as a design's origin names it: `link:<id>`, `secret_key:<id>` and `publishable_key:<id>`, or `store:<site>`. */
                                sources: string[];
                                /** @description When its switch was turned off: the snapshot is as of then. */
                                takenAt: number;
                            } | null;
                        };
                        spendLimit: number;
                        /** @description Where it stands: `enabled` or `disabled`; `failing` while its latest firing failed; `broken` while it cannot fire at all, because its author lacks a grant it needs. `reason` says why, in words. */
                        standing: {
                            state: string;
                        } | {
                            reason: string;
                            /** @enum {string} */
                            state: "failing";
                        } | {
                            code: string;
                            reason: string;
                            /** @enum {string} */
                            state: "broken";
                        };
                        /** @description The event it fires on; null for none yet. */
                        trigger: string | null;
                        /** @description When it was last saved: a save names it as `expectedUpdatedAt`. */
                        updatedAt: number;
                        /** @description Its current version. */
                        version: number;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: feature_disabled, admin_only, origin_forbidden, forbidden */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                        /** @description Always sent with `admin_only`. */
                        reason?: string;
                    };
                };
            };
            /** @description Refused: automation_not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "automations.enable": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": {
                    /** @description The `updatedAt` it was read at. One saved since is refused `automation_changed`, naming who saved it and when, and left disabled. Left out: whatever version is current is enabled. */
                    expectedUpdatedAt?: number;
                } | null;
            };
        };
        responses: {
            /** @description The automation */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description The member whose grants it acts with: whoever last saved it. Null when it runs as the workspace. */
                        author: {
                            name: string | null;
                            userId: string;
                        } | null;
                        /** @description The automation's tree of steps. */
                        body: {
                            /** @description When its steps run: conditions on the subject, combined with `all`, `any` and `not`. Left out, whenever the trigger happens in its sources. */
                            conditions?: {
                                /** @description Every one holds. */
                                all: unknown[];
                            } | {
                                /** @description At least one holds. */
                                any: unknown[];
                            } | {
                                /** @description It does not hold. */
                                not?: unknown;
                            } | {
                                /** @description The fact compared. */
                                field: string;
                                /** @description It holds when the fact is one of these: each at most 200 characters, or 2054 for an origin, which may name a store's site. */
                                in: string[];
                            } | {
                                /** @description It holds from this many copies up. */
                                atLeast?: number;
                                /** @description It holds up to this many copies. */
                                atMost?: number;
                                /**
                                 * @description The order's quantity.
                                 * @enum {string}
                                 */
                                field: "quantity";
                            } | {
                                /**
                                 * @description The order's delivery address.
                                 * @enum {string}
                                 */
                                field: "delivery_address";
                                /** @description Whether it must be set, or must not. */
                                present: boolean;
                            };
                            /** @description The steps, in the order they run. A step's `type` names an action from the catalogue. */
                            steps: {
                                /** @description Further steps, under each branch's name. */
                                branches?: {
                                    [key: string]: unknown[];
                                };
                                /** @description Its id, unique in the body: what a firing names it by. */
                                id: string;
                                /**
                                 * @description What its type takes; the draft check refuses settings the type does not.
                                 * @default {}
                                 */
                                settings: {
                                    [key: string]: unknown;
                                };
                                /** @description Its action (approve, create_print, place_order, reroute, cancel_order, notify, email, webhook) or flow step (only_if, paths, wait_for, delay). */
                                type: string;
                            }[];
                        };
                        createdAt: number;
                        enabled: boolean;
                        /** @description When it was last enabled: it never fires on an event from before. Null for one never enabled. */
                        enabledAt: number | null;
                        firings: {
                            count: number;
                            lastAt: number | null;
                            paused: number;
                            /** @description Spend actions it took in the last 24 hours, against its spend limit. */
                            spentToday: number;
                            waiting: number;
                        };
                        id: string;
                        name: string;
                        runsAs: string;
                        /** @description The sources it acts on: the studio always; designer links, keys and connected stores, each every one or a snapshot. To act on only some, an Only if compares the design's `origin`. */
                        sources: {
                            /** @description On, it acts on designs from every secret and publishable key no store was given, those added later too. Off, only from those in `keys`. */
                            includeNewKeys: boolean;
                            /** @description On, it acts on designs from every designer link, those made later too. Off, only from the links in `links`. */
                            includeNewLinks: boolean;
                            /** @description On, it acts on designs from every connected store, those connected later too. Off, only from those in `stores`. A store may have its own automated flows on its designs; if it does, the first to move one on wins. */
                            includeNewStores: boolean;
                            /** @description While its switch is off, those that existed when it was switched off; null while it is on. A save that turns it off with none takes it then. */
                            keys: {
                                /** @description Each one that existed then, as a design's origin names it: `link:<id>`, `secret_key:<id>` and `publishable_key:<id>`, or `store:<site>`. */
                                sources: string[];
                                /** @description When its switch was turned off: the snapshot is as of then. */
                                takenAt: number;
                            } | null;
                            /** @description While its switch is off, those that existed when it was switched off; null while it is on. A save that turns it off with none takes it then. */
                            links: {
                                /** @description Each one that existed then, as a design's origin names it: `link:<id>`, `secret_key:<id>` and `publishable_key:<id>`, or `store:<site>`. */
                                sources: string[];
                                /** @description When its switch was turned off: the snapshot is as of then. */
                                takenAt: number;
                            } | null;
                            /** @description While its switch is off, those that existed when it was switched off; null while it is on. A save that turns it off with none takes it then. */
                            stores: {
                                /** @description Each one that existed then, as a design's origin names it: `link:<id>`, `secret_key:<id>` and `publishable_key:<id>`, or `store:<site>`. */
                                sources: string[];
                                /** @description When its switch was turned off: the snapshot is as of then. */
                                takenAt: number;
                            } | null;
                        };
                        spendLimit: number;
                        /** @description Where it stands: `enabled` or `disabled`; `failing` while its latest firing failed; `broken` while it cannot fire at all, because its author lacks a grant it needs. `reason` says why, in words. */
                        standing: {
                            state: string;
                        } | {
                            reason: string;
                            /** @enum {string} */
                            state: "failing";
                        } | {
                            code: string;
                            reason: string;
                            /** @enum {string} */
                            state: "broken";
                        };
                        /** @description The event it fires on; null for none yet. */
                        trigger: string | null;
                        /** @description When it was last saved: a save names it as `expectedUpdatedAt`. */
                        updatedAt: number;
                        /** @description Its current version. */
                        version: number;
                    };
                };
            };
            /** @description Refused: invalid_body */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `invalid_body`. */
                        fields?: string[];
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: feature_disabled, admin_only, origin_forbidden, forbidden */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                        /** @description Always sent with `admin_only`. */
                        reason?: string;
                    };
                };
            };
            /** @description Refused: automation_not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: automation_changed, automation_no_trigger */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `automation_no_trigger`. */
                        reason?: string;
                        /** @description Always sent with `automation_changed`. */
                        savedAt?: number;
                        /** @description Who saved it: a member, or a secret key by the label it had then. Always sent with `automation_changed`. */
                        savedBy?: {
                            /** @enum {string} */
                            kind: "member";
                            name: string | null;
                            userId: string;
                        } | {
                            /** @enum {string} */
                            kind: "key";
                            label: string;
                        };
                    };
                };
            };
            /** @description Refused: payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "automations.firings": {
        parameters: {
            query?: {
                /** @description The page to read, from 1; the first when left out. */
                page?: number;
                pageSize?: number;
                /** @description Only the firings in this state; `done` is one that succeeded. */
                status?: "all" | "failed" | "waiting" | "paused" | "done";
                /** @description Only the firings that touched this design, print file or order, by its id. */
                q?: string;
            };
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description A page of the automation's firings */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description How many firings each status filter holds. */
                        counts: {
                            all: number;
                            done: number;
                            failed: number;
                            paused: number;
                            waiting: number;
                        };
                        firings: {
                            finishedAt: number | null;
                            id: string;
                            /** @description Whose grants it ran with: its author's, or the workspace's. */
                            ranAs: {
                                /** @enum {string} */
                                kind: "member";
                                name: string | null;
                                userId: string;
                            } | {
                                /** @enum {string} */
                                kind: "workspace";
                            };
                            /** @description Why it failed, paused or was cancelled, in Pixonaut's words. For an MCP key, a reason that may carry a printshop's own answer (an email's or a printshop step's) is replaced: it can name the order's customer. */
                            reason: string | null;
                            startedAt: number;
                            state: string;
                            /** @description The step it got to, and that step's reason; null before any. For an MCP key, a reason that may carry a printshop's own answer (an email's or a printshop step's) is replaced: it can name the order's customer. */
                            step: {
                                reason: string | null;
                                state: string;
                                stepId: string;
                                type: string;
                            } | null;
                            /** @description What it acts on, by id. */
                            subject: {
                                designId: string | null;
                                orderId: string | null;
                                printId: string | null;
                                /** @description The name of the template its design was made from, which is how a design is named; null once the design is gone. */
                                templateName: string | null;
                            };
                            /** @description Every design, print file and order id it touched. */
                            touched: string[];
                            /** @description The version it runs on. */
                            version: number;
                        }[];
                        page: number;
                        pageSize: number;
                        /** @description How many the chosen filter holds. */
                        total: number;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: feature_disabled, origin_forbidden, forbidden */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: automation_not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: invalid_query */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "automations.firing": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
                firingId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The firing */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        chain: {
                            /** @description The automation whose action set it off; null when nobody's did. */
                            causedBy: {
                                automationId: string;
                                /** @description What the automation was called when it acted. */
                                automationName: string;
                                firingId: string;
                            } | null;
                            /** @description How many firings deep it is, from 1. */
                            depth: number;
                            /** @description The event that started the chain. */
                            rootEventId: string;
                        };
                        /** @description The event that set it off. */
                        event: {
                            at: number | null;
                            id: string;
                            type: string;
                        };
                        finishedAt: number | null;
                        id: string;
                        /** @description What members did to it, oldest first. */
                        manualActions: {
                            action: string;
                            at: number;
                            /** @description Who saved it: a member, or a secret key by the label it had then. */
                            by: {
                                /** @enum {string} */
                                kind: "member";
                                name: string | null;
                                userId: string;
                            } | {
                                /** @enum {string} */
                                kind: "key";
                                label: string;
                            };
                        }[];
                        /** @description Whose grants it ran with: its author's, or the workspace's. */
                        ranAs: {
                            /** @enum {string} */
                            kind: "member";
                            name: string | null;
                            userId: string;
                        } | {
                            /** @enum {string} */
                            kind: "workspace";
                        };
                        /** @description Why it failed, paused or was cancelled, in Pixonaut's words. For an MCP key, a reason that may carry a printshop's own answer (an email's or a printshop step's) is replaced: it can name the order's customer. */
                        reason: string | null;
                        startedAt: number;
                        state: string;
                        /** @description The step it got to, and that step's reason; null before any. For an MCP key, a reason that may carry a printshop's own answer (an email's or a printshop step's) is replaced: it can name the order's customer. */
                        step: {
                            reason: string | null;
                            state: string;
                            stepId: string;
                            type: string;
                        } | null;
                        /** @description Every step of its version, in order, branches after their step; one it never got to is `not_reached`. */
                        steps: {
                            at: number | null;
                            attempts: number;
                            /** @description The branches it sits in, from the top; empty for a step of the body itself. */
                            branch: string[];
                            label: string | null;
                            /** @description When it is tried again, while it is retrying. */
                            nextTryAt: number | null;
                            /** @description For an MCP key, a reason that may carry a printshop's own answer (an email's or a printshop step's) is replaced: it can name the order's customer. */
                            reason: string | null;
                            state: string;
                            stepId: string;
                            subjects: {
                                designId?: string;
                                orderId?: string;
                                printId?: string;
                                printshopId?: string;
                            };
                            type: string;
                            /** @description The email it would have sent, done in a sandbox, which sends no email to anyone who is not a member; null otherwise, and for an MCP key. */
                            unsent: {
                                /** @description false when its texts name a customer's personal data, which a firing never keeps: subject and text are then as written. */
                                filled: boolean;
                                subject: string;
                                text: string;
                                to: string[];
                            } | null;
                            /** @description When it stops waiting, while it waits. */
                            waitingUntil: number | null;
                        }[];
                        /** @description What it acts on, by id. */
                        subject: {
                            designId: string | null;
                            orderId: string | null;
                            printId: string | null;
                            /** @description The name of the template its design was made from, which is how a design is named; null once the design is gone. */
                            templateName: string | null;
                        };
                        /** @description Every design, print file and order id it touched. */
                        touched: string[];
                        /** @description The version it runs on. */
                        version: number;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: feature_disabled, origin_forbidden, forbidden */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: automation_not_found, firing_not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "automations.firings.cancel": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
                firingId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The firing as it is now */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        chain: {
                            /** @description The automation whose action set it off; null when nobody's did. */
                            causedBy: {
                                automationId: string;
                                /** @description What the automation was called when it acted. */
                                automationName: string;
                                firingId: string;
                            } | null;
                            /** @description How many firings deep it is, from 1. */
                            depth: number;
                            /** @description The event that started the chain. */
                            rootEventId: string;
                        };
                        /** @description The event that set it off. */
                        event: {
                            at: number | null;
                            id: string;
                            type: string;
                        };
                        finishedAt: number | null;
                        id: string;
                        /** @description What members did to it, oldest first. */
                        manualActions: {
                            action: string;
                            at: number;
                            /** @description Who saved it: a member, or a secret key by the label it had then. */
                            by: {
                                /** @enum {string} */
                                kind: "member";
                                name: string | null;
                                userId: string;
                            } | {
                                /** @enum {string} */
                                kind: "key";
                                label: string;
                            };
                        }[];
                        /** @description Whose grants it ran with: its author's, or the workspace's. */
                        ranAs: {
                            /** @enum {string} */
                            kind: "member";
                            name: string | null;
                            userId: string;
                        } | {
                            /** @enum {string} */
                            kind: "workspace";
                        };
                        /** @description Why it failed, paused or was cancelled, in Pixonaut's words. For an MCP key, a reason that may carry a printshop's own answer (an email's or a printshop step's) is replaced: it can name the order's customer. */
                        reason: string | null;
                        startedAt: number;
                        state: string;
                        /** @description The step it got to, and that step's reason; null before any. For an MCP key, a reason that may carry a printshop's own answer (an email's or a printshop step's) is replaced: it can name the order's customer. */
                        step: {
                            reason: string | null;
                            state: string;
                            stepId: string;
                            type: string;
                        } | null;
                        /** @description Every step of its version, in order, branches after their step; one it never got to is `not_reached`. */
                        steps: {
                            at: number | null;
                            attempts: number;
                            /** @description The branches it sits in, from the top; empty for a step of the body itself. */
                            branch: string[];
                            label: string | null;
                            /** @description When it is tried again, while it is retrying. */
                            nextTryAt: number | null;
                            /** @description For an MCP key, a reason that may carry a printshop's own answer (an email's or a printshop step's) is replaced: it can name the order's customer. */
                            reason: string | null;
                            state: string;
                            stepId: string;
                            subjects: {
                                designId?: string;
                                orderId?: string;
                                printId?: string;
                                printshopId?: string;
                            };
                            type: string;
                            /** @description The email it would have sent, done in a sandbox, which sends no email to anyone who is not a member; null otherwise, and for an MCP key. */
                            unsent: {
                                /** @description false when its texts name a customer's personal data, which a firing never keeps: subject and text are then as written. */
                                filled: boolean;
                                subject: string;
                                text: string;
                                to: string[];
                            } | null;
                            /** @description When it stops waiting, while it waits. */
                            waitingUntil: number | null;
                        }[];
                        /** @description What it acts on, by id. */
                        subject: {
                            designId: string | null;
                            orderId: string | null;
                            printId: string | null;
                            /** @description The name of the template its design was made from, which is how a design is named; null once the design is gone. */
                            templateName: string | null;
                        };
                        /** @description Every design, print file and order id it touched. */
                        touched: string[];
                        /** @description The version it runs on. */
                        version: number;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: feature_disabled, origin_forbidden, forbidden */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: automation_not_found, firing_not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: firing_control_refused */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `firing_control_refused`. */
                        reason?: string;
                    };
                };
            };
            /** @description Refused: payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "automations.firings.resume": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
                firingId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The firing as it is now */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        chain: {
                            /** @description The automation whose action set it off; null when nobody's did. */
                            causedBy: {
                                automationId: string;
                                /** @description What the automation was called when it acted. */
                                automationName: string;
                                firingId: string;
                            } | null;
                            /** @description How many firings deep it is, from 1. */
                            depth: number;
                            /** @description The event that started the chain. */
                            rootEventId: string;
                        };
                        /** @description The event that set it off. */
                        event: {
                            at: number | null;
                            id: string;
                            type: string;
                        };
                        finishedAt: number | null;
                        id: string;
                        /** @description What members did to it, oldest first. */
                        manualActions: {
                            action: string;
                            at: number;
                            /** @description Who saved it: a member, or a secret key by the label it had then. */
                            by: {
                                /** @enum {string} */
                                kind: "member";
                                name: string | null;
                                userId: string;
                            } | {
                                /** @enum {string} */
                                kind: "key";
                                label: string;
                            };
                        }[];
                        /** @description Whose grants it ran with: its author's, or the workspace's. */
                        ranAs: {
                            /** @enum {string} */
                            kind: "member";
                            name: string | null;
                            userId: string;
                        } | {
                            /** @enum {string} */
                            kind: "workspace";
                        };
                        /** @description Why it failed, paused or was cancelled, in Pixonaut's words. For an MCP key, a reason that may carry a printshop's own answer (an email's or a printshop step's) is replaced: it can name the order's customer. */
                        reason: string | null;
                        startedAt: number;
                        state: string;
                        /** @description The step it got to, and that step's reason; null before any. For an MCP key, a reason that may carry a printshop's own answer (an email's or a printshop step's) is replaced: it can name the order's customer. */
                        step: {
                            reason: string | null;
                            state: string;
                            stepId: string;
                            type: string;
                        } | null;
                        /** @description Every step of its version, in order, branches after their step; one it never got to is `not_reached`. */
                        steps: {
                            at: number | null;
                            attempts: number;
                            /** @description The branches it sits in, from the top; empty for a step of the body itself. */
                            branch: string[];
                            label: string | null;
                            /** @description When it is tried again, while it is retrying. */
                            nextTryAt: number | null;
                            /** @description For an MCP key, a reason that may carry a printshop's own answer (an email's or a printshop step's) is replaced: it can name the order's customer. */
                            reason: string | null;
                            state: string;
                            stepId: string;
                            subjects: {
                                designId?: string;
                                orderId?: string;
                                printId?: string;
                                printshopId?: string;
                            };
                            type: string;
                            /** @description The email it would have sent, done in a sandbox, which sends no email to anyone who is not a member; null otherwise, and for an MCP key. */
                            unsent: {
                                /** @description false when its texts name a customer's personal data, which a firing never keeps: subject and text are then as written. */
                                filled: boolean;
                                subject: string;
                                text: string;
                                to: string[];
                            } | null;
                            /** @description When it stops waiting, while it waits. */
                            waitingUntil: number | null;
                        }[];
                        /** @description What it acts on, by id. */
                        subject: {
                            designId: string | null;
                            orderId: string | null;
                            printId: string | null;
                            /** @description The name of the template its design was made from, which is how a design is named; null once the design is gone. */
                            templateName: string | null;
                        };
                        /** @description Every design, print file and order id it touched. */
                        touched: string[];
                        /** @description The version it runs on. */
                        version: number;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: feature_disabled, origin_forbidden, forbidden */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: automation_not_found, firing_not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: firing_control_refused */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `firing_control_refused`. */
                        reason?: string;
                    };
                };
            };
            /** @description Refused: payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "automations.firings.retry": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
                firingId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The firing as it is now */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        chain: {
                            /** @description The automation whose action set it off; null when nobody's did. */
                            causedBy: {
                                automationId: string;
                                /** @description What the automation was called when it acted. */
                                automationName: string;
                                firingId: string;
                            } | null;
                            /** @description How many firings deep it is, from 1. */
                            depth: number;
                            /** @description The event that started the chain. */
                            rootEventId: string;
                        };
                        /** @description The event that set it off. */
                        event: {
                            at: number | null;
                            id: string;
                            type: string;
                        };
                        finishedAt: number | null;
                        id: string;
                        /** @description What members did to it, oldest first. */
                        manualActions: {
                            action: string;
                            at: number;
                            /** @description Who saved it: a member, or a secret key by the label it had then. */
                            by: {
                                /** @enum {string} */
                                kind: "member";
                                name: string | null;
                                userId: string;
                            } | {
                                /** @enum {string} */
                                kind: "key";
                                label: string;
                            };
                        }[];
                        /** @description Whose grants it ran with: its author's, or the workspace's. */
                        ranAs: {
                            /** @enum {string} */
                            kind: "member";
                            name: string | null;
                            userId: string;
                        } | {
                            /** @enum {string} */
                            kind: "workspace";
                        };
                        /** @description Why it failed, paused or was cancelled, in Pixonaut's words. For an MCP key, a reason that may carry a printshop's own answer (an email's or a printshop step's) is replaced: it can name the order's customer. */
                        reason: string | null;
                        startedAt: number;
                        state: string;
                        /** @description The step it got to, and that step's reason; null before any. For an MCP key, a reason that may carry a printshop's own answer (an email's or a printshop step's) is replaced: it can name the order's customer. */
                        step: {
                            reason: string | null;
                            state: string;
                            stepId: string;
                            type: string;
                        } | null;
                        /** @description Every step of its version, in order, branches after their step; one it never got to is `not_reached`. */
                        steps: {
                            at: number | null;
                            attempts: number;
                            /** @description The branches it sits in, from the top; empty for a step of the body itself. */
                            branch: string[];
                            label: string | null;
                            /** @description When it is tried again, while it is retrying. */
                            nextTryAt: number | null;
                            /** @description For an MCP key, a reason that may carry a printshop's own answer (an email's or a printshop step's) is replaced: it can name the order's customer. */
                            reason: string | null;
                            state: string;
                            stepId: string;
                            subjects: {
                                designId?: string;
                                orderId?: string;
                                printId?: string;
                                printshopId?: string;
                            };
                            type: string;
                            /** @description The email it would have sent, done in a sandbox, which sends no email to anyone who is not a member; null otherwise, and for an MCP key. */
                            unsent: {
                                /** @description false when its texts name a customer's personal data, which a firing never keeps: subject and text are then as written. */
                                filled: boolean;
                                subject: string;
                                text: string;
                                to: string[];
                            } | null;
                            /** @description When it stops waiting, while it waits. */
                            waitingUntil: number | null;
                        }[];
                        /** @description What it acts on, by id. */
                        subject: {
                            designId: string | null;
                            orderId: string | null;
                            printId: string | null;
                            /** @description The name of the template its design was made from, which is how a design is named; null once the design is gone. */
                            templateName: string | null;
                        };
                        /** @description Every design, print file and order id it touched. */
                        touched: string[];
                        /** @description The version it runs on. */
                        version: number;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: feature_disabled, origin_forbidden, forbidden */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: automation_not_found, firing_not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: firing_control_refused */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `firing_control_refused`. */
                        reason?: string;
                    };
                };
            };
            /** @description Refused: payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "automations.applyToPastEvents": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description Confirms what firing on these events may spend without a person. Required, true, when the automation holds a spend action. */
                    confirmSpend?: boolean;
                    /** @description How many events the preview said the window holds: a window that holds another number now is refused, so it fires on the events that were previewed. */
                    expectedEvents?: number;
                    /** @description The window's start, inclusive. */
                    from: number;
                    /** @description The window's end, inclusive; not in the future. */
                    to: number;
                };
            };
        };
        responses: {
            /** @description What it fired on */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description How many events the window held. */
                        events: number;
                        /** @description How many firings that opened: events outside its scope, its conditions unmet or already fired on open none. */
                        opened: number;
                    };
                };
            };
            /** @description Refused: invalid_body */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `invalid_body`. */
                        fields?: string[];
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: feature_disabled, origin_forbidden, forbidden */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: automation_not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: automation_disabled, past_events_changed */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description How many events the window holds now. Always sent with `past_events_changed`. */
                        events?: number;
                        /** @description Always sent with `automation_disabled`, `past_events_changed`. */
                        reason?: string;
                    };
                };
            };
            /** @description Refused: window_refused, spend_unconfirmed, payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Sent with `payload_too_large`. */
                        bytes?: number;
                        error: string;
                        /** @description How many events the window holds, when there are too many. Sent with `window_refused`. */
                        events?: number;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                        /** @description Always sent with `window_refused`, `spend_unconfirmed`. */
                        reason?: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "automations.pastEventsPreview": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description The window's start, inclusive. */
                    from: number;
                    /** @description The window's end, inclusive; not in the future. */
                    to: number;
                };
            };
        };
        responses: {
            /** @description What applying it would fire on */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description How many events the window holds. */
                        events: number;
                        /** @description Whether it holds a spend action: applying it needs the spend confirmation. */
                        spends: boolean;
                        /** @description A test run on the newest; null for an empty window. */
                        testRun: {
                            /** @description Its conditions, each with the values compared; null for none. */
                            conditions: {
                                holds: boolean;
                                leaves: {
                                    field: string;
                                    /** @description What the subject has, compared. */
                                    has: string[] | number | boolean | null;
                                    holds: boolean;
                                    /** @description Where it sits in the tree, as `all.0.not`; empty for a tree of one. */
                                    path: string;
                                    wants: {
                                        [key: string]: unknown;
                                    };
                                }[];
                            } | null;
                            event: {
                                at: number;
                                id: string;
                                type: string;
                            };
                            /** @description Whether the automation would fire on it. */
                            fires: boolean;
                            /** @description Why it would not fire. */
                            reason: string | null;
                            /** @description Every step, in order, branches after their step: what it would do. */
                            steps: {
                                branch: string[];
                                label: string | null;
                                outcome: string;
                                /** @description The printshop it would act at, and what it could do. */
                                printshops: ({
                                    /** @enum {string} */
                                    can: "yes";
                                    id: string;
                                    name: string;
                                } | {
                                    /** @enum {string} */
                                    can: "no";
                                    id: string;
                                    name: string;
                                    /** @description Why it cannot act there. */
                                    reason: string;
                                } | {
                                    /** @enum {string} */
                                    can: "conditional";
                                    id: string;
                                    name: string;
                                    /** @description When it can: checked when it runs, and a step that meets it unmet is blocked. */
                                    rule: string;
                                })[];
                                /** @description Why it is blocked, would pause or would stop; what a wait or a delay would wait for; the path a choice of paths would take. */
                                reason: string | null;
                                /** @description Its placeholders as they render for this event. Empty for an MCP key: a text written to an order's own printshop may name its customer. */
                                rendered: {
                                    [key: string]: string;
                                };
                                /** @description The limits a spend action counts against, as they would stand when it ran. */
                                spend: {
                                    automation: {
                                        limit: number;
                                        used: number;
                                    };
                                    workspace: {
                                        ceiling: number;
                                        used: number;
                                    };
                                } | null;
                                stepId: string;
                                type: string;
                            }[];
                            /** @description What it was about, by id. */
                            subject: {
                                designId?: string;
                                orderId?: string;
                                printId?: string;
                                revision?: number;
                            } | null;
                        } | null;
                    };
                };
            };
            /** @description Refused: invalid_body */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `invalid_body`. */
                        fields?: string[];
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: feature_disabled, origin_forbidden, forbidden */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: automation_not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: automation_disabled */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `automation_disabled`. */
                        reason?: string;
                    };
                };
            };
            /** @description Refused: window_refused, payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Sent with `payload_too_large`. */
                        bytes?: number;
                        error: string;
                        /** @description How many events the window holds, when there are too many. Sent with `window_refused`. */
                        events?: number;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                        /** @description Always sent with `window_refused`. */
                        reason?: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "automations.versions": {
        parameters: {
            query?: {
                /** @description The page to read, from 1; the first when left out. */
                page?: number;
                pageSize?: number;
            };
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description A page of the automation's versions */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        page: number;
                        pageSize: number;
                        /** @description How many there are in all. */
                        total: number;
                        versions: {
                            /** @description What it changed from the version before, in words. */
                            changes: {
                                field: string;
                                summary: string;
                            }[];
                            current: boolean;
                            /** @description The draft as this version saved it: what a new draft starts from, to save as the next version. */
                            draft: {
                                /** @description The automation's tree of steps. */
                                body: {
                                    /** @description When its steps run: conditions on the subject, combined with `all`, `any` and `not`. Left out, whenever the trigger happens in its sources. */
                                    conditions?: {
                                        /** @description Every one holds. */
                                        all: unknown[];
                                    } | {
                                        /** @description At least one holds. */
                                        any: unknown[];
                                    } | {
                                        /** @description It does not hold. */
                                        not?: unknown;
                                    } | {
                                        /** @description The fact compared. */
                                        field: string;
                                        /** @description It holds when the fact is one of these: each at most 200 characters, or 2054 for an origin, which may name a store's site. */
                                        in: string[];
                                    } | {
                                        /** @description It holds from this many copies up. */
                                        atLeast?: number;
                                        /** @description It holds up to this many copies. */
                                        atMost?: number;
                                        /**
                                         * @description The order's quantity.
                                         * @enum {string}
                                         */
                                        field: "quantity";
                                    } | {
                                        /**
                                         * @description The order's delivery address.
                                         * @enum {string}
                                         */
                                        field: "delivery_address";
                                        /** @description Whether it must be set, or must not. */
                                        present: boolean;
                                    };
                                    /** @description The steps, in the order they run. A step's `type` names an action from the catalogue. */
                                    steps: {
                                        /** @description Further steps, under each branch's name. */
                                        branches?: {
                                            [key: string]: unknown[];
                                        };
                                        /** @description Its id, unique in the body: what a firing names it by. */
                                        id: string;
                                        /**
                                         * @description What its type takes; the draft check refuses settings the type does not.
                                         * @default {}
                                         */
                                        settings: {
                                            [key: string]: unknown;
                                        };
                                        /** @description Its action (approve, create_print, place_order, reroute, cancel_order, notify, email, webhook) or flow step (only_if, paths, wait_for, delay). */
                                        type: string;
                                    }[];
                                };
                                name: string;
                                runsAs: string;
                                /** @description The sources it acts on: the studio always; designer links, keys and connected stores, each every one or a snapshot. To act on only some, an Only if compares the design's `origin`. */
                                sources: {
                                    /** @description On, it acts on designs from every secret and publishable key no store was given, those added later too. Off, only from those in `keys`. */
                                    includeNewKeys: boolean;
                                    /** @description On, it acts on designs from every designer link, those made later too. Off, only from the links in `links`. */
                                    includeNewLinks: boolean;
                                    /** @description On, it acts on designs from every connected store, those connected later too. Off, only from those in `stores`. A store may have its own automated flows on its designs; if it does, the first to move one on wins. */
                                    includeNewStores: boolean;
                                    /** @description While its switch is off, those that existed when it was switched off; null while it is on. A save that turns it off with none takes it then. */
                                    keys: {
                                        /** @description Each one that existed then, as a design's origin names it: `link:<id>`, `secret_key:<id>` and `publishable_key:<id>`, or `store:<site>`. */
                                        sources: string[];
                                        /** @description When its switch was turned off: the snapshot is as of then. */
                                        takenAt: number;
                                    } | null;
                                    /** @description While its switch is off, those that existed when it was switched off; null while it is on. A save that turns it off with none takes it then. */
                                    links: {
                                        /** @description Each one that existed then, as a design's origin names it: `link:<id>`, `secret_key:<id>` and `publishable_key:<id>`, or `store:<site>`. */
                                        sources: string[];
                                        /** @description When its switch was turned off: the snapshot is as of then. */
                                        takenAt: number;
                                    } | null;
                                    /** @description While its switch is off, those that existed when it was switched off; null while it is on. A save that turns it off with none takes it then. */
                                    stores: {
                                        /** @description Each one that existed then, as a design's origin names it: `link:<id>`, `secret_key:<id>` and `publishable_key:<id>`, or `store:<site>`. */
                                        sources: string[];
                                        /** @description When its switch was turned off: the snapshot is as of then. */
                                        takenAt: number;
                                    } | null;
                                };
                                spendLimit: number;
                                /** @description The event it fires on; null for none yet. */
                                trigger: string | null;
                            };
                            savedAt: number;
                            /** @description Who saved it: a member, or a secret key by the label it had then. */
                            savedBy: {
                                /** @enum {string} */
                                kind: "member";
                                name: string | null;
                                userId: string;
                            } | {
                                /** @enum {string} */
                                kind: "key";
                                label: string;
                            };
                            /** @description Firings that started on it and are still running, waiting or paused. */
                            unfinishedFirings: number;
                            version: number;
                        }[];
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: automation_not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: invalid_query */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "blanks.list": {
        parameters: {
            query?: {
                /** @description The page to read, from 1; the first when left out. */
                page?: number;
                pageSize?: number;
                q?: string;
                hasPlacements?: "true" | "false";
                printshop?: string;
                category?: string;
                pageOf?: string;
                deleted?: "only";
                orderedFirstFor?: string;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description A page of blanks */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        blanks: {
                            /** @description The options the blank's print areas change with, such as Size, in option order; empty for one print area per placement. Each placement's `areas` names a row of these. */
                            areasVaryBy: string[];
                            /** @description The blank's option axes, such as Color and Size, in the order the shopper sees them. Empty for a blank with one variant. */
                            axes: string[];
                            /** @description The partner's product a bound blank (`partnerLocked`) is bound to, or null for a blank bound to none. Answered for one blank, never in a list. */
                            boundProduct?: {
                                /** @description The partner's own id of the product. */
                                id: string;
                                /** @description The product's name as the printshop last reported it: at import, then at each check for printshop changes. Null when the record of the import is gone. */
                                name: string | null;
                            } | null;
                            categoryId: string | null;
                            /** @description The blank this one was copied to its printshop from, or null. */
                            copiedFrom: {
                                /** @description The source blank's id, which may since have been deleted. */
                                blankId: string;
                                /** @description The source blank's name when it was copied. */
                                name: string;
                            } | null;
                            createdAt: number;
                            defaultPrintshopId: string;
                            /** @description When and by whom the blank was deleted, or null for a blank that is not. A deleted blank is read-only: restore it to change it. */
                            deleted: {
                                /** @description When the blank was deleted, epoch ms. */
                                at: number;
                                /** @description The member who deleted it; null when a key did. */
                                by: {
                                    /** @description The member's name as it is now; null once unknown. */
                                    name: string | null;
                                    userId: string;
                                } | null;
                            } | null;
                            id: string;
                            /** @description The code a failed import failed with, such as `partner_failed` or `storage_quota_exceeded`; null unless `status` is `failed`. */
                            importFailure: string | null;
                            machineProfileId: string | null;
                            name: string;
                            /** @description The blank's options with their values, in the order the shopper sees them, a value no variant uses yet included. `axes` is their names. */
                            options: {
                                /** @description How each value looks to a shopper, by value: a colour fill, an image, or null for none. Every value of `values` is named. */
                                appearances: {
                                    [key: string]: {
                                        /** @description One `#rrggbb` colour, or two for a heather or two-tone, drawn half and half. */
                                        colours: string[];
                                        /** @enum {string} */
                                        kind: "fill";
                                    } | {
                                        /** @description An image in the workspace's asset library. */
                                        assetId: string;
                                        /** @enum {string} */
                                        kind: "image";
                                    } | null;
                                };
                                /** @description The option's name per customer-facing language, by code: only the languages it has one in. A language left out reads `name`. */
                                localizedNames?: {
                                    da?: string;
                                    de?: string;
                                    en?: string;
                                    es?: string;
                                    fi?: string;
                                    fr?: string;
                                    nb?: string;
                                    nl?: string;
                                    sv?: string;
                                };
                                /** @description Each value's name per customer-facing language, by value: only the values that have one. A language left out reads the value itself. */
                                localizedValues?: {
                                    [key: string]: {
                                        da?: string;
                                        de?: string;
                                        en?: string;
                                        es?: string;
                                        fi?: string;
                                        fr?: string;
                                        nb?: string;
                                        nl?: string;
                                        sv?: string;
                                    };
                                };
                                name: string;
                                values: string[];
                            }[];
                            /** @description When the blank's options were confirmed: the merchant said it has one version, or added its first option. Null until then. A blank imported from a printshop's catalogue arrives confirmed. */
                            optionsConfirmedAt: number | null;
                            /** @description How many orders name the blank, past ones included. Answered in a list, never for one blank, and only to a caller with `orders:read`. */
                            orderCount?: number;
                            partnerLocked: boolean;
                            /** @description How much of the blank is photographed. Answered in a list. */
                            photoCoverage?: {
                                /** @description The blank's rows (each combination of the values of the options its photos change with; one for All) times its views. */
                                cells: number;
                                /** @description The cells with a photo, of their own row or a covering one. */
                                filled: number;
                            };
                            /** @description The options the blank's photos change with, in option order: each photo belongs to one row, its values of these, and shows every variant with them. Empty is All: one photo per view shows every variant. */
                            photosVaryBy: string[];
                            /** @description The blank's placements: the areas a design is printed into. An update replaces the whole list, so send every placement to keep. */
                            placements: {
                                /** @description The placement's print area per row of the blank's `areasVaryBy` options, such as one per size; omitted or empty, the placement has one print area, its own. maxWidthMm and maxHeightMm are then the widest and tallest row, which every row fits inside. */
                                areas?: {
                                    /** @description Bleed past the trim on the row, in millimetres, 0 to 50. Omitted, the placement's. */
                                    bleedMm?: number;
                                    /** @description Print resolution on the row in dots per inch. Omitted, the placement's. */
                                    dpi?: number;
                                    /** @description The tallest print the row takes, in millimetres. */
                                    heightMm: number;
                                    /** @description The row: a value for each `areasVaryBy` option, by option name. One area per row per placement. */
                                    row: {
                                        [key: string]: string;
                                    };
                                    /** @description Safe area inside the trim on the row, in millimetres, 0 to 50. Omitted, the placement's. */
                                    safeAreaMm?: number;
                                    /** @description The height a print gets on the row when none is chosen, in millimetres, at most heightMm. */
                                    usualHeightMm: number;
                                    /** @description The width a print gets on the row when none is chosen, in millimetres, at most widthMm. */
                                    usualWidthMm: number;
                                    /** @description The widest print the row takes, in millimetres. */
                                    widthMm: number;
                                }[];
                                /** @description Bleed past the trim on each side, in millimetres, 0 to 50. Omitted, its category's, else the workspace's. */
                                bleedMm?: number;
                                /** @description How a print covers the placement: `within`, a print of any size up to the maximum placed inside it, or `full`, a print that is the whole area, such as an all-over-print panel. Omitted, `within`. A `full` placement's usual size is its area, and a request naming a smaller size is refused `print_size_not_area`. */
                                coverage?: string;
                                /** @description The height a print gets when none is chosen, in millimetres, at most maxHeightMm. */
                                defaultHeightMm: number;
                                /** @description The width a print gets when none is chosen, in millimetres, at most maxWidthMm. */
                                defaultWidthMm: number;
                                /** @description Print resolution in dots per inch. Omitted, its category's, else 300. */
                                dpi?: number;
                                /** @description The `#rrggbb` colour an optional placement left undesigned is printed or delivered as. Null or omitted for none. */
                                fillColour?: string | null;
                                /** @description Unique within the blank; a short stable one such as `front`, which a template refers to it by. */
                                id: string;
                                /** @description The placement it is linked with by default, such as a right sleeve with the left one: one design then drives both unless a designer link, an SDK mount or a design says otherwise. Null or omitted for none. A placement linked with one no longer on the blank is linked with none. */
                                linkWith?: {
                                    /** @description Whether this placement's print is mirrored left to right when the two are linked. */
                                    mirror: boolean;
                                    /** @description The id of the blank's other placement it is linked with by default. */
                                    placementId: string;
                                } | null;
                                /** @description The tallest print the placement takes, in millimetres. */
                                maxHeightMm: number;
                                /** @description The widest print the placement takes, in millimetres. */
                                maxWidthMm: number;
                                /** @description What it is called, such as Front or Back. */
                                name: string;
                                /** @description How this placement is printed, such as dtg or screen. Omitted, its category's. */
                                printMethod?: string;
                                /** @description Whether an order on the blank must print it: one without a print for it is refused `placement_unfilled`. Omitted is false; a blank bound to its printshop's product takes it from the printshop. */
                                required?: boolean;
                                /** @description Safe area inside the trim on each side, in millimetres, 0 to 50. Omitted, its category's, else the workspace's. */
                                safeAreaMm?: number;
                                /** @description Where on the product a print may go when that is not the whole rectangle: `dFrac`, SVG path data in fractions of the print area (curves, no arcs), its first subpath the outline and every further one a cut-out, filled even-odd, each subpath closed. Nothing is printed outside the outline or in a cut-out. `cutByPrintShop` true adds the outline and the cut-outs to the print file as its cut line; omitted, the product already has the shape. Null or omitted, the whole rectangle. */
                                shape?: {
                                    /** @description True when the print shop cuts the product to this shape: the outline and the cut-outs go into the print file as its cut line. Omitted, the product already has the shape. */
                                    cutByPrintShop?: boolean;
                                    /** @description The shape as SVG path data in fractions of the print area, 0 to 1 across and down (curves, no arcs): its first subpath the outline, every further one a cut-out, filled even-odd, each subpath closed. */
                                    dFrac: string;
                                } | null;
                                /** @description Printed as: the name the blank's printshop knows the placement by, on orders and job sheets. Null or omitted prints the placement's name. */
                                shopName?: string | null;
                                /** @description The ways the placement is photographed, such as Flat or On model. Every photo of one view shares its pixel size and its print area. */
                                views: {
                                    /** @description True on a view a blank bound to its printshop's product took from the printshop (its import, Add colours, model photos): its photo size and print area are the printshop's and cannot change by hand. Absent on a view the workspace added. Set only by the printshop's own paths; a save that sends it is ignored. */
                                    fromPrintshop?: boolean;
                                    /** @description Unique within the blank. */
                                    id: string;
                                    /** @description What it is called, such as Flat or On model; unique within its placement, ignoring case. */
                                    label: string;
                                    /** @description What it is called per customer-facing language, by code: only the languages it has a name in; a language left out reads `label`. No two views of its placement read the same in one language, ignoring case. */
                                    localizedLabels?: {
                                        da?: string;
                                        de?: string;
                                        en?: string;
                                        es?: string;
                                        fi?: string;
                                        fr?: string;
                                        nb?: string;
                                        nl?: string;
                                        sv?: string;
                                    };
                                    /** @description A library asset of the view's photo size: where it is light the print shows, where it is dark the print is hidden, as behind a sleeve or a fold. Absent hides nothing. */
                                    maskAssetId?: string;
                                    /** @description Control points the print is laid through or, marked cut, cut to, rows from its top edge and points from its left, as [x, y] in the photo's original pixels; at least 2 and at most 33 along each side. Absent, the print is laid in the rect. */
                                    mesh?: {
                                        /**
                                         * @description The points draw a shape to cut the print to (CONTEXT.md → Region cut) rather than a mesh to bend it through: the print is laid flat over the box the points span, at its own proportions and filling it, and everything outside the shape the outer points draw is cut away. Absent, the print is warped through the mesh.
                                         * @enum {boolean}
                                         */
                                        cut?: true;
                                        /** @description The rows of control points, from the print's top edge. */
                                        points: number[][][];
                                    };
                                    /** @description The printshop's own key for the photo style the view was made from, such as a model or lifestyle style; absent on a view made by hand or imported with the product. */
                                    partnerStyleKey?: string;
                                    /** @description The pixel size every photo of the view has; null until the view holds a photo. */
                                    photoSizePx: {
                                        /** @description The photo's height, in pixels. */
                                        heightPx: number;
                                        /** @description The photo's width, in pixels. */
                                        widthPx: number;
                                    } | null;
                                    /** @description The view's product photos, each the same size as the view. */
                                    photos: {
                                        /** @description The photo's asset id, as the assets feature returns it after an upload. */
                                        assetId: string;
                                        /** @description How far the photo's folds move the design, more than 0 and at most 1. null moves nothing. Omitted, its category's, else nothing. */
                                        displacementStrength?: number | null;
                                        /** @description The photo's id, unique within the blank: the `mockupId` a render and a mockup link name. */
                                        id: string;
                                        /** @description The photo's value of each `photosVaryBy` option; empty when there are none. One photo per row per view. */
                                        row?: {
                                            [key: string]: string;
                                        };
                                        /** @description How strongly the photo's light and shade carry onto the design, 0 (none) to 1 (all). Omitted, its category's, else the default strength. */
                                        shadingStrength?: number;
                                        /** @description How strongly the photo's fine detail, such as a weave or a grain, shows through the print, 0 (none) to 1 (all). Omitted, its category's, else, as for null, the default strength. */
                                        textureStrength?: number | null;
                                        /** @description The variants the photo shows, from its `row`. A write may name the row by these instead. */
                                        variantRefs?: string[];
                                        /** @description How the design wraps round the product. null lies it flat. Omitted, its category's, else flat. */
                                        warp?: {
                                            /** @description How far round the product the design wraps, more than 0 and at most 1. Flat is a null warp, not 0. */
                                            curvature: number;
                                            /** @description How much the design darkens toward the product's sides, 0 (none) to 1 (black at the edge). Omitted, none. */
                                            edgeFalloff?: number;
                                            /** @description The kind of wrap; `cylinder` is the only one. */
                                            kind: string;
                                        } | null;
                                    }[];
                                    /** @description A pattern piece of the view's UV pass, 1 to 254: the region's print is read through the pixels the pass marks with it, in place of a mesh. */
                                    piece?: number;
                                    /** @description Where the print area sits on every photo of the view, in the original photo's pixels; null until it is marked. */
                                    placementRectPx: {
                                        /** @description The print area's height, in pixels. */
                                        h: number;
                                        /** @description The print area's width, in pixels. */
                                        w: number;
                                        /** @description The print area's left edge, in pixels from the photo's left. */
                                        x: number;
                                        /** @description The print area's top edge, in pixels from the photo's top. */
                                        y: number;
                                    } | null;
                                    /** @description The part of the region's piece its print covers, in millimetres on the piece's unwrapped surface from its top-left corner, such as a square on the side of a cup: the print is read inside it, at the window's size, and the product shows plain outside it. It lies inside its piece, and needs the piece's size on the view. Absent, the print covers the whole piece. */
                                    printWindowMm?: {
                                        /** @description The window's height, in mm. */
                                        heightMm: number;
                                        /** @description The window's width, in mm. */
                                        widthMm: number;
                                        /** @description The window's left edge, in mm from the piece's left. */
                                        xMm: number;
                                        /** @description The window's top edge, in mm from the piece's top. */
                                        yMm: number;
                                    };
                                    /** @description The piece of the placement's print the region shows, in millimetres from the print's top-left corner, such as a roll's window; clamped to the print when the print is smaller. Absent, the region shows the whole print at the size of the render's variant. */
                                    sourceWindowMm?: {
                                        /** @description The window's height, in mm. */
                                        heightMm: number;
                                        /** @description The window's width, in mm. */
                                        widthMm: number;
                                        /** @description The window's left edge, in mm from the print's left. */
                                        xMm: number;
                                        /** @description The window's top edge, in mm from the print's top. */
                                        yMm: number;
                                    };
                                    /** @description The maps the view was rendered with from a 3D model of the product, each the view's photo size; a region naming a piece is drawn through them. Absent, the view's regions are laid in their rect or mesh. */
                                    uvPasses?: {
                                        /** @description The multiply pass: the garment's shadows and folds. */
                                        multiplyAssetId: string;
                                        /** @description Each piece's print size on the model, as its `view.json` gives it: what a region's print window is placed on. Absent, no region of the view may name a print window. */
                                        pieceSizesMm?: {
                                            /** @description The piece's print height on the model, in mm. */
                                            heightMm: number;
                                            /** @description A pattern piece of the view's UV pass, 1 to 254: the region's print is read through the pixels the pass marks with it, in place of a mesh. */
                                            piece: number;
                                            /** @description The piece's print width on the model, in mm. */
                                            widthMm: number;
                                        }[];
                                        /** @description The pieces the UV pass marks, as its `view.json` lists them. */
                                        pieces: number[];
                                        /** @description The screen pass: the garment's highlights. */
                                        screenAssetId: string;
                                        /** @description The 16-bit UV pass: for each pixel, its piece (blue) and where across (red) and down (green) that piece's print it reads. */
                                        uvAssetId: string;
                                    };
                                }[];
                            }[];
                            /** @description The placements printed as a position that prints one size only at the blank's printshop whose default print size is another size: flagged, never refused, since an order of the position's size is still taken. Answered for one blank, never in a list. */
                            placementsAtOtherSize?: {
                                placementId: string;
                                /** @description The printshop's position the placement is printed as. */
                                position: string;
                                /** @description The one size that position prints, in mm. */
                                sizeMm: {
                                    heightMm: number;
                                    widthMm: number;
                                };
                            }[];
                            /** @description The row a design that names none is made at, such as {"Size": "M"}; null for none, when such a design reads each placement's own print area. Required when the print areas start to change with an option on a blank that has designs or designer links, which keep their size at it. */
                            referenceRow: {
                                [key: string]: string;
                            } | null;
                            /** @description Each inheritable field resolved, with where it comes from: the printshop and machine, and every placement's and photo's printing fields and preview looks, in the order of `placements`. */
                            resolved: {
                                defaultPrintshopId: {
                                    /** @description Where the value comes from: the field's own, its blank category's, the workspace's default, or none (nothing sets it, and the built-in default applies). */
                                    source: string;
                                    value: string | null;
                                };
                                machineProfileId: {
                                    /** @description Where the value comes from: the field's own, its blank category's, the workspace's default, or none (nothing sets it, and the built-in default applies). */
                                    source: string;
                                    value: string | null;
                                };
                                placements: {
                                    bleedMm: {
                                        /** @description Where the value comes from: the field's own, its blank category's, the workspace's default, or none (nothing sets it, and the built-in default applies). */
                                        source: string;
                                        value: number | null;
                                    };
                                    dpi: {
                                        /** @description Where the value comes from: the field's own, its blank category's, the workspace's default, or none (nothing sets it, and the built-in default applies). */
                                        source: string;
                                        value: number | null;
                                    };
                                    id: string;
                                    /** @description The placement's photos, every view's in view order. */
                                    mockups: {
                                        displacementStrength: {
                                            /** @description Where the value comes from: the field's own, its blank category's, the workspace's default, or none (nothing sets it, and the built-in default applies). */
                                            source: string;
                                            value: number | null;
                                        };
                                        id: string;
                                        shadingStrength: {
                                            /** @description Where the value comes from: the field's own, its blank category's, the workspace's default, or none (nothing sets it, and the built-in default applies). */
                                            source: string;
                                            value: number | null;
                                        };
                                        textureStrength: {
                                            /** @description Where the value comes from: the field's own, its blank category's, the workspace's default, or none (nothing sets it, and the built-in default applies). */
                                            source: string;
                                            value: number | null;
                                        };
                                        warp: {
                                            /** @description Where the value comes from: the field's own, its blank category's, the workspace's default, or none (nothing sets it, and the built-in default applies). */
                                            source: string;
                                            value: {
                                                /** @description How far round the product the design wraps, more than 0 and at most 1. Flat is a null warp, not 0. */
                                                curvature: number;
                                                /** @description How much the design darkens toward the product's sides, 0 (none) to 1 (black at the edge). Omitted, none. */
                                                edgeFalloff?: number;
                                                /** @description The kind of wrap; `cylinder` is the only one. */
                                                kind: string;
                                            } | null;
                                        };
                                    }[];
                                    printMethod: {
                                        /** @description Where the value comes from: the field's own, its blank category's, the workspace's default, or none (nothing sets it, and the built-in default applies). */
                                        source: string;
                                        value: string | null;
                                    };
                                    /** @description Printed as: the name the blank's printshop knows the placement by, on orders and job sheets. The placement's own shopName, else its name. */
                                    printedAs: string;
                                    /** @description Whether Printed as follows the placement's name: true while it has no shopName of its own. */
                                    printedAsLinked: boolean;
                                    safeAreaMm: {
                                        /** @description Where the value comes from: the field's own, its blank category's, the workspace's default, or none (nothing sets it, and the built-in default applies). */
                                        source: string;
                                        value: number | null;
                                    };
                                }[];
                            };
                            /** @description The first photo of the blank's first view of several placements that has one, in their order: the view, the photo (a mockup), its asset and the view's photo size. A blank whose views of one placement have no photo is pictured by it. Null for a blank with no such photo. Answered in a list. */
                            sharedViewPhoto?: {
                                assetId: string;
                                mockupId: string;
                                photoSizePx: {
                                    /** @description The photo's height, in pixels. */
                                    heightPx: number;
                                    /** @description The photo's width, in pixels. */
                                    widthPx: number;
                                } | null;
                                viewId: string;
                            } | null;
                            /** @description `importing` while the blank's import, from a printshop's catalogue or a CSV file, runs in the background: it has its name and nothing else yet. `failed` when that import failed for good (`importFailure` says why); remove it and import again. `ready` otherwise. */
                            status: string;
                            /** @description A link to the blank's picture, opening with no key for an hour or two, so a list shows a picture of each blank: its first photo of a view of one placement, else `sharedViewPhoto`. Null for a blank with no photo. Answered in a list. */
                            thumbnailUrl?: string | null;
                            updatedAt: number;
                            /** @description How many variants the blank has, deleted ones included. Answered in a list. */
                            variantCount?: number;
                            /** @description The blank's variants, retired ones included, with their printshop fields. Answered for one blank, never in a list. */
                            variants?: {
                                attributes: {
                                    [key: string]: string | number | boolean;
                                };
                                options: {
                                    [key: string]: string;
                                };
                                partnerKey: string | null;
                                ref: string;
                                retired: {
                                    reason: string;
                                } | null;
                                updatedAt: number;
                            }[];
                        }[];
                        orderedFirst: boolean;
                        page: number;
                        pageSize: number;
                        total: number;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: invalid_query */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "blanks.get": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The blank */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description The options the blank's print areas change with, such as Size, in option order; empty for one print area per placement. Each placement's `areas` names a row of these. */
                        areasVaryBy: string[];
                        /** @description The blank's option axes, such as Color and Size, in the order the shopper sees them. Empty for a blank with one variant. */
                        axes: string[];
                        /** @description The partner's product a bound blank (`partnerLocked`) is bound to, or null for a blank bound to none. Answered for one blank, never in a list. */
                        boundProduct?: {
                            /** @description The partner's own id of the product. */
                            id: string;
                            /** @description The product's name as the printshop last reported it: at import, then at each check for printshop changes. Null when the record of the import is gone. */
                            name: string | null;
                        } | null;
                        categoryId: string | null;
                        /** @description The blank this one was copied to its printshop from, or null. */
                        copiedFrom: {
                            /** @description The source blank's id, which may since have been deleted. */
                            blankId: string;
                            /** @description The source blank's name when it was copied. */
                            name: string;
                        } | null;
                        createdAt: number;
                        defaultPrintshopId: string;
                        /** @description When and by whom the blank was deleted, or null for a blank that is not. A deleted blank is read-only: restore it to change it. */
                        deleted: {
                            /** @description When the blank was deleted, epoch ms. */
                            at: number;
                            /** @description The member who deleted it; null when a key did. */
                            by: {
                                /** @description The member's name as it is now; null once unknown. */
                                name: string | null;
                                userId: string;
                            } | null;
                        } | null;
                        id: string;
                        /** @description The code a failed import failed with, such as `partner_failed` or `storage_quota_exceeded`; null unless `status` is `failed`. */
                        importFailure: string | null;
                        machineProfileId: string | null;
                        name: string;
                        /** @description The blank's options with their values, in the order the shopper sees them, a value no variant uses yet included. `axes` is their names. */
                        options: {
                            /** @description How each value looks to a shopper, by value: a colour fill, an image, or null for none. Every value of `values` is named. */
                            appearances: {
                                [key: string]: {
                                    /** @description One `#rrggbb` colour, or two for a heather or two-tone, drawn half and half. */
                                    colours: string[];
                                    /** @enum {string} */
                                    kind: "fill";
                                } | {
                                    /** @description An image in the workspace's asset library. */
                                    assetId: string;
                                    /** @enum {string} */
                                    kind: "image";
                                } | null;
                            };
                            /** @description The option's name per customer-facing language, by code: only the languages it has one in. A language left out reads `name`. */
                            localizedNames?: {
                                da?: string;
                                de?: string;
                                en?: string;
                                es?: string;
                                fi?: string;
                                fr?: string;
                                nb?: string;
                                nl?: string;
                                sv?: string;
                            };
                            /** @description Each value's name per customer-facing language, by value: only the values that have one. A language left out reads the value itself. */
                            localizedValues?: {
                                [key: string]: {
                                    da?: string;
                                    de?: string;
                                    en?: string;
                                    es?: string;
                                    fi?: string;
                                    fr?: string;
                                    nb?: string;
                                    nl?: string;
                                    sv?: string;
                                };
                            };
                            name: string;
                            values: string[];
                        }[];
                        /** @description When the blank's options were confirmed: the merchant said it has one version, or added its first option. Null until then. A blank imported from a printshop's catalogue arrives confirmed. */
                        optionsConfirmedAt: number | null;
                        /** @description How many orders name the blank, past ones included. Answered in a list, never for one blank, and only to a caller with `orders:read`. */
                        orderCount?: number;
                        partnerLocked: boolean;
                        /** @description How much of the blank is photographed. Answered in a list. */
                        photoCoverage?: {
                            /** @description The blank's rows (each combination of the values of the options its photos change with; one for All) times its views. */
                            cells: number;
                            /** @description The cells with a photo, of their own row or a covering one. */
                            filled: number;
                        };
                        /** @description The options the blank's photos change with, in option order: each photo belongs to one row, its values of these, and shows every variant with them. Empty is All: one photo per view shows every variant. */
                        photosVaryBy: string[];
                        /** @description The blank's placements: the areas a design is printed into. An update replaces the whole list, so send every placement to keep. */
                        placements: {
                            /** @description The placement's print area per row of the blank's `areasVaryBy` options, such as one per size; omitted or empty, the placement has one print area, its own. maxWidthMm and maxHeightMm are then the widest and tallest row, which every row fits inside. */
                            areas?: {
                                /** @description Bleed past the trim on the row, in millimetres, 0 to 50. Omitted, the placement's. */
                                bleedMm?: number;
                                /** @description Print resolution on the row in dots per inch. Omitted, the placement's. */
                                dpi?: number;
                                /** @description The tallest print the row takes, in millimetres. */
                                heightMm: number;
                                /** @description The row: a value for each `areasVaryBy` option, by option name. One area per row per placement. */
                                row: {
                                    [key: string]: string;
                                };
                                /** @description Safe area inside the trim on the row, in millimetres, 0 to 50. Omitted, the placement's. */
                                safeAreaMm?: number;
                                /** @description The height a print gets on the row when none is chosen, in millimetres, at most heightMm. */
                                usualHeightMm: number;
                                /** @description The width a print gets on the row when none is chosen, in millimetres, at most widthMm. */
                                usualWidthMm: number;
                                /** @description The widest print the row takes, in millimetres. */
                                widthMm: number;
                            }[];
                            /** @description Bleed past the trim on each side, in millimetres, 0 to 50. Omitted, its category's, else the workspace's. */
                            bleedMm?: number;
                            /** @description How a print covers the placement: `within`, a print of any size up to the maximum placed inside it, or `full`, a print that is the whole area, such as an all-over-print panel. Omitted, `within`. A `full` placement's usual size is its area, and a request naming a smaller size is refused `print_size_not_area`. */
                            coverage?: string;
                            /** @description The height a print gets when none is chosen, in millimetres, at most maxHeightMm. */
                            defaultHeightMm: number;
                            /** @description The width a print gets when none is chosen, in millimetres, at most maxWidthMm. */
                            defaultWidthMm: number;
                            /** @description Print resolution in dots per inch. Omitted, its category's, else 300. */
                            dpi?: number;
                            /** @description The `#rrggbb` colour an optional placement left undesigned is printed or delivered as. Null or omitted for none. */
                            fillColour?: string | null;
                            /** @description Unique within the blank; a short stable one such as `front`, which a template refers to it by. */
                            id: string;
                            /** @description The placement it is linked with by default, such as a right sleeve with the left one: one design then drives both unless a designer link, an SDK mount or a design says otherwise. Null or omitted for none. A placement linked with one no longer on the blank is linked with none. */
                            linkWith?: {
                                /** @description Whether this placement's print is mirrored left to right when the two are linked. */
                                mirror: boolean;
                                /** @description The id of the blank's other placement it is linked with by default. */
                                placementId: string;
                            } | null;
                            /** @description The tallest print the placement takes, in millimetres. */
                            maxHeightMm: number;
                            /** @description The widest print the placement takes, in millimetres. */
                            maxWidthMm: number;
                            /** @description What it is called, such as Front or Back. */
                            name: string;
                            /** @description How this placement is printed, such as dtg or screen. Omitted, its category's. */
                            printMethod?: string;
                            /** @description Whether an order on the blank must print it: one without a print for it is refused `placement_unfilled`. Omitted is false; a blank bound to its printshop's product takes it from the printshop. */
                            required?: boolean;
                            /** @description Safe area inside the trim on each side, in millimetres, 0 to 50. Omitted, its category's, else the workspace's. */
                            safeAreaMm?: number;
                            /** @description Where on the product a print may go when that is not the whole rectangle: `dFrac`, SVG path data in fractions of the print area (curves, no arcs), its first subpath the outline and every further one a cut-out, filled even-odd, each subpath closed. Nothing is printed outside the outline or in a cut-out. `cutByPrintShop` true adds the outline and the cut-outs to the print file as its cut line; omitted, the product already has the shape. Null or omitted, the whole rectangle. */
                            shape?: {
                                /** @description True when the print shop cuts the product to this shape: the outline and the cut-outs go into the print file as its cut line. Omitted, the product already has the shape. */
                                cutByPrintShop?: boolean;
                                /** @description The shape as SVG path data in fractions of the print area, 0 to 1 across and down (curves, no arcs): its first subpath the outline, every further one a cut-out, filled even-odd, each subpath closed. */
                                dFrac: string;
                            } | null;
                            /** @description Printed as: the name the blank's printshop knows the placement by, on orders and job sheets. Null or omitted prints the placement's name. */
                            shopName?: string | null;
                            /** @description The ways the placement is photographed, such as Flat or On model. Every photo of one view shares its pixel size and its print area. */
                            views: {
                                /** @description True on a view a blank bound to its printshop's product took from the printshop (its import, Add colours, model photos): its photo size and print area are the printshop's and cannot change by hand. Absent on a view the workspace added. Set only by the printshop's own paths; a save that sends it is ignored. */
                                fromPrintshop?: boolean;
                                /** @description Unique within the blank. */
                                id: string;
                                /** @description What it is called, such as Flat or On model; unique within its placement, ignoring case. */
                                label: string;
                                /** @description What it is called per customer-facing language, by code: only the languages it has a name in; a language left out reads `label`. No two views of its placement read the same in one language, ignoring case. */
                                localizedLabels?: {
                                    da?: string;
                                    de?: string;
                                    en?: string;
                                    es?: string;
                                    fi?: string;
                                    fr?: string;
                                    nb?: string;
                                    nl?: string;
                                    sv?: string;
                                };
                                /** @description A library asset of the view's photo size: where it is light the print shows, where it is dark the print is hidden, as behind a sleeve or a fold. Absent hides nothing. */
                                maskAssetId?: string;
                                /** @description Control points the print is laid through or, marked cut, cut to, rows from its top edge and points from its left, as [x, y] in the photo's original pixels; at least 2 and at most 33 along each side. Absent, the print is laid in the rect. */
                                mesh?: {
                                    /**
                                     * @description The points draw a shape to cut the print to (CONTEXT.md → Region cut) rather than a mesh to bend it through: the print is laid flat over the box the points span, at its own proportions and filling it, and everything outside the shape the outer points draw is cut away. Absent, the print is warped through the mesh.
                                     * @enum {boolean}
                                     */
                                    cut?: true;
                                    /** @description The rows of control points, from the print's top edge. */
                                    points: number[][][];
                                };
                                /** @description The printshop's own key for the photo style the view was made from, such as a model or lifestyle style; absent on a view made by hand or imported with the product. */
                                partnerStyleKey?: string;
                                /** @description The pixel size every photo of the view has; null until the view holds a photo. */
                                photoSizePx: {
                                    /** @description The photo's height, in pixels. */
                                    heightPx: number;
                                    /** @description The photo's width, in pixels. */
                                    widthPx: number;
                                } | null;
                                /** @description The view's product photos, each the same size as the view. */
                                photos: {
                                    /** @description The photo's asset id, as the assets feature returns it after an upload. */
                                    assetId: string;
                                    /** @description How far the photo's folds move the design, more than 0 and at most 1. null moves nothing. Omitted, its category's, else nothing. */
                                    displacementStrength?: number | null;
                                    /** @description The photo's id, unique within the blank: the `mockupId` a render and a mockup link name. */
                                    id: string;
                                    /** @description The photo's value of each `photosVaryBy` option; empty when there are none. One photo per row per view. */
                                    row?: {
                                        [key: string]: string;
                                    };
                                    /** @description How strongly the photo's light and shade carry onto the design, 0 (none) to 1 (all). Omitted, its category's, else the default strength. */
                                    shadingStrength?: number;
                                    /** @description How strongly the photo's fine detail, such as a weave or a grain, shows through the print, 0 (none) to 1 (all). Omitted, its category's, else, as for null, the default strength. */
                                    textureStrength?: number | null;
                                    /** @description The variants the photo shows, from its `row`. A write may name the row by these instead. */
                                    variantRefs?: string[];
                                    /** @description How the design wraps round the product. null lies it flat. Omitted, its category's, else flat. */
                                    warp?: {
                                        /** @description How far round the product the design wraps, more than 0 and at most 1. Flat is a null warp, not 0. */
                                        curvature: number;
                                        /** @description How much the design darkens toward the product's sides, 0 (none) to 1 (black at the edge). Omitted, none. */
                                        edgeFalloff?: number;
                                        /** @description The kind of wrap; `cylinder` is the only one. */
                                        kind: string;
                                    } | null;
                                }[];
                                /** @description A pattern piece of the view's UV pass, 1 to 254: the region's print is read through the pixels the pass marks with it, in place of a mesh. */
                                piece?: number;
                                /** @description Where the print area sits on every photo of the view, in the original photo's pixels; null until it is marked. */
                                placementRectPx: {
                                    /** @description The print area's height, in pixels. */
                                    h: number;
                                    /** @description The print area's width, in pixels. */
                                    w: number;
                                    /** @description The print area's left edge, in pixels from the photo's left. */
                                    x: number;
                                    /** @description The print area's top edge, in pixels from the photo's top. */
                                    y: number;
                                } | null;
                                /** @description The part of the region's piece its print covers, in millimetres on the piece's unwrapped surface from its top-left corner, such as a square on the side of a cup: the print is read inside it, at the window's size, and the product shows plain outside it. It lies inside its piece, and needs the piece's size on the view. Absent, the print covers the whole piece. */
                                printWindowMm?: {
                                    /** @description The window's height, in mm. */
                                    heightMm: number;
                                    /** @description The window's width, in mm. */
                                    widthMm: number;
                                    /** @description The window's left edge, in mm from the piece's left. */
                                    xMm: number;
                                    /** @description The window's top edge, in mm from the piece's top. */
                                    yMm: number;
                                };
                                /** @description The piece of the placement's print the region shows, in millimetres from the print's top-left corner, such as a roll's window; clamped to the print when the print is smaller. Absent, the region shows the whole print at the size of the render's variant. */
                                sourceWindowMm?: {
                                    /** @description The window's height, in mm. */
                                    heightMm: number;
                                    /** @description The window's width, in mm. */
                                    widthMm: number;
                                    /** @description The window's left edge, in mm from the print's left. */
                                    xMm: number;
                                    /** @description The window's top edge, in mm from the print's top. */
                                    yMm: number;
                                };
                                /** @description The maps the view was rendered with from a 3D model of the product, each the view's photo size; a region naming a piece is drawn through them. Absent, the view's regions are laid in their rect or mesh. */
                                uvPasses?: {
                                    /** @description The multiply pass: the garment's shadows and folds. */
                                    multiplyAssetId: string;
                                    /** @description Each piece's print size on the model, as its `view.json` gives it: what a region's print window is placed on. Absent, no region of the view may name a print window. */
                                    pieceSizesMm?: {
                                        /** @description The piece's print height on the model, in mm. */
                                        heightMm: number;
                                        /** @description A pattern piece of the view's UV pass, 1 to 254: the region's print is read through the pixels the pass marks with it, in place of a mesh. */
                                        piece: number;
                                        /** @description The piece's print width on the model, in mm. */
                                        widthMm: number;
                                    }[];
                                    /** @description The pieces the UV pass marks, as its `view.json` lists them. */
                                    pieces: number[];
                                    /** @description The screen pass: the garment's highlights. */
                                    screenAssetId: string;
                                    /** @description The 16-bit UV pass: for each pixel, its piece (blue) and where across (red) and down (green) that piece's print it reads. */
                                    uvAssetId: string;
                                };
                            }[];
                        }[];
                        /** @description The placements printed as a position that prints one size only at the blank's printshop whose default print size is another size: flagged, never refused, since an order of the position's size is still taken. Answered for one blank, never in a list. */
                        placementsAtOtherSize?: {
                            placementId: string;
                            /** @description The printshop's position the placement is printed as. */
                            position: string;
                            /** @description The one size that position prints, in mm. */
                            sizeMm: {
                                heightMm: number;
                                widthMm: number;
                            };
                        }[];
                        /** @description The row a design that names none is made at, such as {"Size": "M"}; null for none, when such a design reads each placement's own print area. Required when the print areas start to change with an option on a blank that has designs or designer links, which keep their size at it. */
                        referenceRow: {
                            [key: string]: string;
                        } | null;
                        /** @description Each inheritable field resolved, with where it comes from: the printshop and machine, and every placement's and photo's printing fields and preview looks, in the order of `placements`. */
                        resolved: {
                            defaultPrintshopId: {
                                /** @description Where the value comes from: the field's own, its blank category's, the workspace's default, or none (nothing sets it, and the built-in default applies). */
                                source: string;
                                value: string | null;
                            };
                            machineProfileId: {
                                /** @description Where the value comes from: the field's own, its blank category's, the workspace's default, or none (nothing sets it, and the built-in default applies). */
                                source: string;
                                value: string | null;
                            };
                            placements: {
                                bleedMm: {
                                    /** @description Where the value comes from: the field's own, its blank category's, the workspace's default, or none (nothing sets it, and the built-in default applies). */
                                    source: string;
                                    value: number | null;
                                };
                                dpi: {
                                    /** @description Where the value comes from: the field's own, its blank category's, the workspace's default, or none (nothing sets it, and the built-in default applies). */
                                    source: string;
                                    value: number | null;
                                };
                                id: string;
                                /** @description The placement's photos, every view's in view order. */
                                mockups: {
                                    displacementStrength: {
                                        /** @description Where the value comes from: the field's own, its blank category's, the workspace's default, or none (nothing sets it, and the built-in default applies). */
                                        source: string;
                                        value: number | null;
                                    };
                                    id: string;
                                    shadingStrength: {
                                        /** @description Where the value comes from: the field's own, its blank category's, the workspace's default, or none (nothing sets it, and the built-in default applies). */
                                        source: string;
                                        value: number | null;
                                    };
                                    textureStrength: {
                                        /** @description Where the value comes from: the field's own, its blank category's, the workspace's default, or none (nothing sets it, and the built-in default applies). */
                                        source: string;
                                        value: number | null;
                                    };
                                    warp: {
                                        /** @description Where the value comes from: the field's own, its blank category's, the workspace's default, or none (nothing sets it, and the built-in default applies). */
                                        source: string;
                                        value: {
                                            /** @description How far round the product the design wraps, more than 0 and at most 1. Flat is a null warp, not 0. */
                                            curvature: number;
                                            /** @description How much the design darkens toward the product's sides, 0 (none) to 1 (black at the edge). Omitted, none. */
                                            edgeFalloff?: number;
                                            /** @description The kind of wrap; `cylinder` is the only one. */
                                            kind: string;
                                        } | null;
                                    };
                                }[];
                                printMethod: {
                                    /** @description Where the value comes from: the field's own, its blank category's, the workspace's default, or none (nothing sets it, and the built-in default applies). */
                                    source: string;
                                    value: string | null;
                                };
                                /** @description Printed as: the name the blank's printshop knows the placement by, on orders and job sheets. The placement's own shopName, else its name. */
                                printedAs: string;
                                /** @description Whether Printed as follows the placement's name: true while it has no shopName of its own. */
                                printedAsLinked: boolean;
                                safeAreaMm: {
                                    /** @description Where the value comes from: the field's own, its blank category's, the workspace's default, or none (nothing sets it, and the built-in default applies). */
                                    source: string;
                                    value: number | null;
                                };
                            }[];
                        };
                        /** @description The first photo of the blank's first view of several placements that has one, in their order: the view, the photo (a mockup), its asset and the view's photo size. A blank whose views of one placement have no photo is pictured by it. Null for a blank with no such photo. Answered in a list. */
                        sharedViewPhoto?: {
                            assetId: string;
                            mockupId: string;
                            photoSizePx: {
                                /** @description The photo's height, in pixels. */
                                heightPx: number;
                                /** @description The photo's width, in pixels. */
                                widthPx: number;
                            } | null;
                            viewId: string;
                        } | null;
                        /** @description `importing` while the blank's import, from a printshop's catalogue or a CSV file, runs in the background: it has its name and nothing else yet. `failed` when that import failed for good (`importFailure` says why); remove it and import again. `ready` otherwise. */
                        status: string;
                        /** @description A link to the blank's picture, opening with no key for an hour or two, so a list shows a picture of each blank: its first photo of a view of one placement, else `sharedViewPhoto`. Null for a blank with no photo. Answered in a list. */
                        thumbnailUrl?: string | null;
                        updatedAt: number;
                        /** @description How many variants the blank has, deleted ones included. Answered in a list. */
                        variantCount?: number;
                        /** @description The blank's variants, retired ones included, with their printshop fields. Answered for one blank, never in a list. */
                        variants?: {
                            attributes: {
                                [key: string]: string | number | boolean;
                            };
                            options: {
                                [key: string]: string;
                            };
                            partnerKey: string | null;
                            ref: string;
                            retired: {
                                reason: string;
                            } | null;
                            updatedAt: number;
                        }[];
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "blanks.mockups.list": {
        parameters: {
            query?: {
                /** @description The language the blank's options, their values and its views are named in, one of `en`, `sv`, `de`, `fr`, `es`, `nl`, `da`, `nb`, `fi`: each name the blank has in it, else its own. Absent, every name is its own. */
                lang?: "en" | "sv" | "de" | "fr" | "es" | "nl" | "da" | "nb" | "fi";
            };
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The blank's placements, each with its views and their photos */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        placements: {
                            /** @description The placement's print area per row of the options the blank's print areas change with (`areasVaryBy` on the variants read): a design on a variant is printed at the area of that variant's row, at its usual size when none is chosen. Empty when the area is the same at every size. */
                            areas: {
                                heightMm: number;
                                row: {
                                    [key: string]: string;
                                };
                                usualHeightMm: number;
                                usualWidthMm: number;
                                widthMm: number;
                            }[];
                            bleedMm: number;
                            /** @description `full` when a print covers the placement's whole area, `within` when it is placed inside it. */
                            coverage: string;
                            defaultHeightMm: number;
                            defaultWidthMm: number;
                            /** @description The colour, `#rrggbb`, a view of several placements shows in this placement's region while it has no print. Absent when the placement names none. */
                            fillColour?: string;
                            id: string;
                            /** @description The placement it is linked with by default, and whether its print is mirrored then: a designer linking the blank's suggested groups joins the two. Absent when it suggests none. */
                            linkWith?: {
                                /** @description Whether this placement's print is mirrored left to right when the two are linked. */
                                mirror: boolean;
                                /** @description The id of the blank's other placement it is linked with by default. */
                                placementId: string;
                            };
                            maxHeightMm: number;
                            maxWidthMm: number;
                            name: string;
                            /** @description How the placement is printed: its own, else its blank category's. Absent when neither names one. */
                            printMethod?: string;
                            safeAreaMm: number;
                            /** @description Where on the product a print may go: the outline, then each cut-out, in fractions of the print area, filled even-odd. A preview clips the print to it and draws it as a guide. Absent when the whole rectangle is printed. */
                            shape?: {
                                /** @description True when the print shop cuts the product to this shape: the outline and the cut-outs go into the print file as its cut line. Omitted, the product already has the shape. */
                                cutByPrintShop?: boolean;
                                /** @description The shape as SVG path data in fractions of the print area, 0 to 1 across and down (curves, no arcs): its first subpath the outline, every further one a cut-out, filled even-odd, each subpath closed. */
                                dFrac: string;
                            };
                            views: {
                                id: string;
                                label: string;
                                /** @description The region's mask, the view's photo size, opened with no key: where it is light the print shows, where it is dark the print is hidden. Absent hides nothing. Valid as long as a photo's `url`. */
                                maskUrl?: string;
                                /** @description Control points the print is laid through or, marked cut, cut to, rows from its top edge and points from its left, as [x, y] in the photo's original pixels; at least 2 and at most 33 along each side. Absent, the print is laid in the rect. */
                                mesh?: {
                                    /**
                                     * @description The points draw a shape to cut the print to (CONTEXT.md → Region cut) rather than a mesh to bend it through: the print is laid flat over the box the points span, at its own proportions and filling it, and everything outside the shape the outer points draw is cut away. Absent, the print is warped through the mesh.
                                     * @enum {boolean}
                                     */
                                    cut?: true;
                                    /** @description The rows of control points, from the print's top edge. */
                                    points: number[][][];
                                };
                                /** @description The pixel size every photo of the view has; null while it has none. */
                                photoSizePx: {
                                    /** @description The photo's height, in pixels. */
                                    heightPx: number;
                                    /** @description The photo's width, in pixels. */
                                    widthPx: number;
                                } | null;
                                photos: {
                                    /** @description The photo's height in pixels; null when `width` is. */
                                    height: number | null;
                                    /** @description The photo's id: the `mockupId` a render names. */
                                    id: string;
                                    /** @description What the designer mounts this mockup with, as one of `mockups` with its view's `label`. Null when the photo has not finished uploading, its size is not known, or its view has no print area marked. */
                                    mount: {
                                        /** @description How far the photo's folds move the design, more than 0 and at most 1. null moves nothing. Omitted, its category's, else nothing. */
                                        displacementStrength?: number | null;
                                        /** @description The size of the photo `placementRectPx` is measured in. The url may serve a smaller copy of it; the designer places the rect on whatever size arrives. */
                                        photoSizePx: {
                                            h: number;
                                            w: number;
                                        };
                                        /** @description Where the print area sits on every photo of the view, in the original photo's pixels; null until it is marked. */
                                        placementRectPx: {
                                            /** @description The print area's height, in pixels. */
                                            h: number;
                                            /** @description The print area's width, in pixels. */
                                            w: number;
                                            /** @description The print area's left edge, in pixels from the photo's left. */
                                            x: number;
                                            /** @description The print area's top edge, in pixels from the photo's top. */
                                            y: number;
                                        };
                                        /** @description How strongly the photo's light and shade carry onto the design, 0 (none) to 1 (all). Omitted, its category's, else the default strength. */
                                        shadingStrength?: number;
                                        /** @description How strongly the photo's fine detail, such as a weave or a grain, shows through the print, 0 (none) to 1 (all). Omitted, its category's, else, as for null, the default strength. */
                                        textureStrength?: number | null;
                                        /** @description The photo, opened with no key. It stays valid for at least 30 days and at most 60, and any cache may keep it that long; it stops opening once the mockup's photo is replaced. Read the blank's mockups again within 30 days for a fresh one. */
                                        url: string;
                                        /** @description How the design wraps round the product. null lies it flat. Omitted, its category's, else flat. */
                                        warp?: {
                                            /** @description How far round the product the design wraps, more than 0 and at most 1. Flat is a null warp, not 0. */
                                            curvature: number;
                                            /** @description How much the design darkens toward the product's sides, 0 (none) to 1 (black at the edge). Omitted, none. */
                                            edgeFalloff?: number;
                                            /** @description The kind of wrap; `cylinder` is the only one. */
                                            kind: string;
                                        } | null;
                                    } | null;
                                    thumbnailUrl: string;
                                    /** @description The refs of the blank's variants the photo shows, so a designer picks a view's photo of the variant chosen. Empty when it names none: on a blank with no Color axis a photo shows every variant. */
                                    variantRefs: string[];
                                    /** @description The photo's width in pixels, so a host reserves the preview's shape before it loads; null while the photo has not finished uploading or its size is not known. */
                                    width: number | null;
                                }[];
                                /** @description A pattern piece of the view's UV pass, 1 to 254: the region's print is read through the pixels the pass marks with it, in place of a mesh. */
                                piece?: number;
                                /** @description The print size on the model of the piece the region's `printWindowMm` lies on, in mm. Present with a print window only. */
                                pieceSizeMm?: {
                                    heightMm: number;
                                    widthMm: number;
                                };
                                /** @description Where the print sits on every photo of the view, in the photo's pixels; null while it is not marked. */
                                placementRectPx: {
                                    /** @description The print area's height, in pixels. */
                                    h: number;
                                    /** @description The print area's width, in pixels. */
                                    w: number;
                                    /** @description The print area's left edge, in pixels from the photo's left. */
                                    x: number;
                                    /** @description The print area's top edge, in pixels from the photo's top. */
                                    y: number;
                                } | null;
                                /** @description The part of the region's piece its print covers, in millimetres on the piece's unwrapped surface from its top-left corner, such as a square on the side of a cup: the print is read inside it, at the window's size, and the product shows plain outside it. It lies inside its piece, and needs the piece's size on the view. Absent, the print covers the whole piece. */
                                printWindowMm?: {
                                    /** @description The window's height, in mm. */
                                    heightMm: number;
                                    /** @description The window's width, in mm. */
                                    widthMm: number;
                                    /** @description The window's left edge, in mm from the piece's left. */
                                    xMm: number;
                                    /** @description The window's top edge, in mm from the piece's top. */
                                    yMm: number;
                                };
                                /** @description The piece of the placement's print the region shows, in millimetres from the print's top-left corner, such as a roll's window; clamped to the print when the print is smaller. Absent, the region shows the whole print at the size of the render's variant. */
                                sourceWindowMm?: {
                                    /** @description The window's height, in mm. */
                                    heightMm: number;
                                    /** @description The window's width, in mm. */
                                    widthMm: number;
                                    /** @description The window's left edge, in mm from the print's left. */
                                    xMm: number;
                                    /** @description The window's top edge, in mm from the print's top. */
                                    yMm: number;
                                };
                                /** @description The maps the view was rendered with from a 3D model of the product, each the view's photo size, opened with no key: a region naming a `piece` is read through them. Absent on a view of photos. Valid as long as a photo's `url`. */
                                uvPassUrls?: {
                                    /** @description The multiply pass: the product's shadows and folds. */
                                    multiply: string;
                                    /** @description The screen pass: the product's highlights. */
                                    screen: string;
                                    /** @description The 16-bit UV pass: for each pixel, its piece (blue) and where across (red) and down (green) that piece's print it reads. */
                                    uv: string;
                                };
                            }[];
                        }[];
                        /** @description The blank's views of several placements, in order: each region with its placement, rect, mesh, window and mask, and each photo with its variants and its looks per region. */
                        views: {
                            /** @description The view's id, unique within the blank. */
                            id: string;
                            label: string;
                            /** @description The pixel size every photo of the view has; null while it has none. */
                            photoSizePx: {
                                /** @description The photo's height, in pixels. */
                                heightPx: number;
                                /** @description The photo's width, in pixels. */
                                widthPx: number;
                            } | null;
                            /** @description The view's photos whose upload has finished, in stored order. */
                            photos: {
                                height: number;
                                /** @description The photo's id, unique within the blank. */
                                id: string;
                                /** @description The photo's looks in each region it sets any for; a region left out takes the defaults. */
                                regions: {
                                    /** @description How far the photo's folds move the design, more than 0 and at most 1. null moves nothing. Omitted, its category's, else nothing. */
                                    displacementStrength?: number | null;
                                    /** @description The region, by its placement. */
                                    placementId: string;
                                    /** @description How strongly the photo's light and shade carry onto the design, 0 (none) to 1 (all). Omitted, its category's, else the default strength. */
                                    shadingStrength?: number;
                                    /** @description How strongly the photo's fine detail, such as a weave or a grain, shows through the print, 0 (none) to 1 (all). Omitted, its category's, else, as for null, the default strength. */
                                    textureStrength?: number | null;
                                    /** @description How the design wraps round the product. null lies it flat. Omitted, its category's, else flat. */
                                    warp?: {
                                        /** @description How far round the product the design wraps, more than 0 and at most 1. Flat is a null warp, not 0. */
                                        curvature: number;
                                        /** @description How much the design darkens toward the product's sides, 0 (none) to 1 (black at the edge). Omitted, none. */
                                        edgeFalloff?: number;
                                        /** @description The kind of wrap; `cylinder` is the only one. */
                                        kind: string;
                                    } | null;
                                }[];
                                /** @description The photo, opened with no key. It stays valid for at least 30 days and at most 60, and any cache may keep it that long; it stops opening once the view no longer shows that photo. */
                                url: string;
                                /** @description The refs of the blank's variants the photo shows. Empty when it names none: on a blank with no Color axis a photo shows every variant. */
                                variantRefs: string[];
                                width: number;
                            }[];
                            /** @description The view's print regions, in the order they are drawn. */
                            regions: {
                                /** @description The region's mask, the view's photo size, opened with no key: where it is light the print shows, where it is dark the print is hidden. Absent hides nothing. Valid as long as a photo's `url`. */
                                maskUrl?: string;
                                /** @description Control points the print is laid through or, marked cut, cut to, rows from its top edge and points from its left, as [x, y] in the photo's original pixels; at least 2 and at most 33 along each side. Absent, the print is laid in the rect. */
                                mesh?: {
                                    /**
                                     * @description The points draw a shape to cut the print to (CONTEXT.md → Region cut) rather than a mesh to bend it through: the print is laid flat over the box the points span, at its own proportions and filling it, and everything outside the shape the outer points draw is cut away. Absent, the print is warped through the mesh.
                                     * @enum {boolean}
                                     */
                                    cut?: true;
                                    /** @description The rows of control points, from the print's top edge. */
                                    points: number[][][];
                                };
                                /** @description A pattern piece of the view's UV pass, 1 to 254: the region's print is read through the pixels the pass marks with it, in place of a mesh. */
                                piece?: number;
                                /** @description The print size on the model of the piece the region's `printWindowMm` lies on, in mm. Present with a print window only. */
                                pieceSizeMm?: {
                                    heightMm: number;
                                    widthMm: number;
                                };
                                /** @description The placement whose print the region shows. */
                                placementId: string;
                                /** @description The part of the region's piece its print covers, in millimetres on the piece's unwrapped surface from its top-left corner, such as a square on the side of a cup: the print is read inside it, at the window's size, and the product shows plain outside it. It lies inside its piece, and needs the piece's size on the view. Absent, the print covers the whole piece. */
                                printWindowMm?: {
                                    /** @description The window's height, in mm. */
                                    heightMm: number;
                                    /** @description The window's width, in mm. */
                                    widthMm: number;
                                    /** @description The window's left edge, in mm from the piece's left. */
                                    xMm: number;
                                    /** @description The window's top edge, in mm from the piece's top. */
                                    yMm: number;
                                };
                                /** @description Where the region's print sits on every photo, in the photo's original pixels; null while it is not marked. */
                                rectPx: {
                                    /** @description The print area's height, in pixels. */
                                    h: number;
                                    /** @description The print area's width, in pixels. */
                                    w: number;
                                    /** @description The print area's left edge, in pixels from the photo's left. */
                                    x: number;
                                    /** @description The print area's top edge, in pixels from the photo's top. */
                                    y: number;
                                } | null;
                                /** @description The piece of the placement's print the region shows, in millimetres from the print's top-left corner, such as a roll's window; clamped to the print when the print is smaller. Absent, the region shows the whole print at the size of the render's variant. */
                                sourceWindowMm?: {
                                    /** @description The window's height, in mm. */
                                    heightMm: number;
                                    /** @description The window's width, in mm. */
                                    widthMm: number;
                                    /** @description The window's left edge, in mm from the print's left. */
                                    xMm: number;
                                    /** @description The window's top edge, in mm from the print's top. */
                                    yMm: number;
                                };
                            }[];
                            /** @description The maps the view was rendered with from a 3D model of the product, each the view's photo size, opened with no key: a region naming a `piece` is read through them. Absent on a view of photos. Valid as long as a photo's `url`. */
                            uvPassUrls?: {
                                /** @description The multiply pass: the product's shadows and folds. */
                                multiply: string;
                                /** @description The screen pass: the product's highlights. */
                                screen: string;
                                /** @description The 16-bit UV pass: for each pixel, its piece (blue) and where across (red) and down (green) that piece's print it reads. */
                                uv: string;
                            };
                        }[];
                    };
                };
            };
            /** @description Refused: invalid_query */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `invalid_query`. */
                        reason?: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, feature_disabled, forbidden, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
            /** @description Refused: print_box_unavailable */
            503: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
        };
    };
    "blanks.placements.fittingTemplates.list": {
        parameters: {
            query?: {
                /** @description The page to read, from 1; the first when left out. */
                page?: number;
                pageSize?: number;
                status?: "all" | "draft" | "live" | "paused";
                q?: string;
            };
            header?: never;
            path: {
                id: string;
                placementId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description A page of templates with their verdicts */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        items: {
                            name: string;
                            /** @description A link to the template's preview, as the template search gives one, opening with no key for an hour or two. Null for a draft never published, which has no version to draw. */
                            previewUrl: string | null;
                            printHeightMm: number;
                            printWidthMm: number;
                            ratio: {
                                /** @description The ratio's height part. Positive. */
                                h: number;
                                /** @description The ratio's width part. Positive. */
                                w: number;
                            };
                            ratioTolerance: number;
                            /** @description The blank's sizes the template can and can't print at, on a placement whose print area changes with an option (coverage `full`, or a position that prints one size only). Both empty on a placement whose area doesn't, which the template fits at every size. */
                            sizes: {
                                /** @description The sizes the template prints at here, by option value, such as `S`; several options' values are joined with ` / `. */
                                fits: string[];
                                /** @description The sizes the template can't print at here: a design at one is refused when committed. */
                                misfits: string[];
                            };
                            status: string;
                            templateId: string;
                            verdict: {
                                /** @enum {boolean} */
                                legal: true;
                            } | {
                                /** @enum {boolean} */
                                legal: false;
                                reason: string;
                            };
                        }[];
                        page: number;
                        pageSize: number;
                        total: number;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: invalid_query */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "blanks.previewTables.get": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
                placementId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The tables a design on the placement is drawn through */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description The CMYK the press prints each point of an sRGB grid as. */
                        estimate: {
                            ghostscriptVersion: string;
                            gridPoints: number;
                            profileSha256: string;
                            /** @description The packed grid, one character per byte (`gridTableText`). */
                            text: string;
                        };
                        /** @description The sRGB each point of a CMYK grid is drawn as on screen. */
                        preview: {
                            ghostscriptVersion: string;
                            gridPoints: number;
                            profileSha256: string;
                            /** @description The packed grid, one character per byte (`gridTableText`). */
                            text: string;
                        };
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, feature_disabled, forbidden, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found, no_preview_tables */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "blanks.variants.list": {
        parameters: {
            query?: {
                /** @description The language the blank's options, their values and its views are named in, one of `en`, `sv`, `de`, `fr`, `es`, `nl`, `da`, `nb`, `fi`: each name the blank has in it, else its own. Absent, every name is its own. */
                lang?: "en" | "sv" | "de" | "fr" | "es" | "nl" | "da" | "nb" | "fi";
            };
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The blank's axes and variants */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description The options the blank's print areas change with, such as Size, in option order; empty for one print area per placement. Each placement's `areas` names a row of these. */
                        areasVaryBy: string[];
                        /** @description The blank's option axes, in the order the shopper sees them. */
                        axes: string[];
                        /** @description The blank's options in that order, each with its values and how each value looks: a designer draws an option whose values have appearances as swatches. */
                        options: {
                            /** @description Each value's appearance, by value: every value is named. */
                            appearances: {
                                [key: string]: {
                                    /** @description One `#rrggbb` colour, or two for a heather or two-tone, drawn half and half. */
                                    colours: string[];
                                    /** @enum {string} */
                                    kind: "fill";
                                } | {
                                    assetId: string;
                                    /** @enum {string} */
                                    kind: "image";
                                    /** @description The picture, opened with no key. It stays valid for at least 30 days and at most 60, and any cache may keep it that long. */
                                    url: string;
                                } | null;
                            };
                            name: string;
                            values: string[];
                        }[];
                        variants: {
                            options: {
                                [key: string]: string;
                            };
                            ref: string;
                            retired: {
                                reason: string;
                            } | null;
                            /** @description The views it has a photo in, in the blank's order: each view whose photo of its row shows it. */
                            views: {
                                label: string;
                                placementId: string;
                                viewId: string;
                            }[];
                        }[];
                    };
                };
            };
            /** @description Refused: invalid_query */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `invalid_query`. */
                        reason?: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, feature_disabled, forbidden, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "blanks.views.mockup.get": {
        parameters: {
            query?: {
                /** @description A variant ref of the blank: the view's photo of it, each region's print at its size. */
                variant?: string;
                /** @description What each region shows: `placementId:templateId@version` pairs, comma-separated, each a published template. A region left out shows its placement's fill colour, or the photo alone. */
                prints?: string;
                /** @description The long edge in pixels, clamped to the sizes the api renders. */
                size?: string;
            };
            header?: never;
            path: {
                /** @description The blank. */
                id: string;
                /** @description One of the blank's views. */
                viewId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The view with its prints */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "image/png": string;
                };
            };
            /** @description The caller's copy, named by its ETag, is current */
            304: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, feature_disabled */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description No blank, view, photo or published template answers to these ids */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Refused: mockup_rect_unusable, mockup_rect_outside_photo, mockup_placed_box_empty, photo_decode_failed, mockup_mesh_unusable, mockup_cut_unusable, mockup_mask_decode_failed, mockup_uv_decode_failed, mockup_uv_pass_mismatch, unknown_variant, variant_retired, variant_has_no_photo, prints_invalid, mockup_mask_unreadable, mockup_uv_unreadable, invalid_query */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `unknown_variant`, `variant_retired`, `variant_has_no_photo`, `prints_invalid`. */
                        reason?: string;
                        /** @description Always sent with `unknown_variant`. */
                        ref?: string;
                        /** @description With `variant_retired`: The retired variant's ref. With `variant_has_no_photo`: The variant's ref. Always sent with `variant_retired`, `variant_has_no_photo`. */
                        variant?: string;
                        /** @description The view's label. Always sent with `variant_has_no_photo`. */
                        view?: string;
                        /** @description Always sent with `variant_has_no_photo`. */
                        viewId?: string;
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: artwork_decode_failed, encode_failed, downscale_size_overflow, input_too_large, mockup_warp_unreadable, mockup_mesh_unreadable, mockup_cut_unreadable, mockup_uv_view_missing, composite_failed, template_defaults_invalid, db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
            /** @description Refused: print_box_unavailable, asset_store_unavailable, assets_unavailable */
            503: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
        };
    };
    "connectedStore.get": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The store's connection */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description The publishable key's origins, the site's own first. */
                        allowedOrigins: string[];
                        /** @description Hours a customer upload nothing holds is kept: the workspace's retention, else the platform's default. */
                        assetTtlHours: number;
                        /** @description The brand chosen for this store, one of `brands`; null when it follows the workspace's default brand. */
                        brandId: string | null;
                        /** @description What the hosted pages the store sends customers to show. A link keeps the brand it was created in; a change applies to links created after it. */
                        branding: {
                            /** @description The colour the hosted pages are drawn in, as `#rrggbb`: an ink's screen colour while the accent is linked to one. null when none is set. */
                            accentColor: string | null;
                            /** @description The brand the store's hosted pages are drawn in now: its own, else the workspace's default. null only for a workspace with no brand yet. */
                            brandId: string | null;
                            /** @description An address the brand's logo loads from for a while; read the connection again for a fresh one. null when no logo is set. */
                            logoUrl: string | null;
                        };
                        /** @description The workspace's brands, the default first, then by name: what the store may choose with `PATCH /v1/connect`. */
                        brands: {
                            /** @description Its accent colour, as `branding.accentColor`. */
                            accentColor: string | null;
                            id: string;
                            /** @description Whether it is the workspace's default brand, which a store with no brand of its own is drawn in. */
                            isDefault: boolean;
                            /** @description An address its logo loads from for a while, as `branding.logoUrl`; null when it has none. */
                            logoUrl: string | null;
                            name: string;
                        }[];
                        connectionId: string;
                        /** @description The workspace's default language, one of `en`, `sv`, `de`, `fr`, `es`, `nl`, `da`, `nb`, `fi`: what its hosted pages and the designer are shown in when a link or a mount names no `locale`. English until the workspace chooses one. */
                        defaultLanguage: string;
                        /** @description The workspace's saved address every new order ships to instead of its customer. null when orders ship to their customer. */
                        deliverOrdersTo: {
                            id: string;
                            name: string;
                        } | null;
                        environment: string;
                        /** @description The integration key's name, which a member may have renamed in the studio. */
                        name: string;
                        /** @description The workspace's print defaults a template falls back to: its own, else the product's. */
                        printing: {
                            /** @description The bleed past the trim that artwork without a blank prints with, in millimetres. */
                            defaultBleedMm: number;
                            /** @description The safe area inside the trim, in millimetres, on the same terms as defaultBleedMm. */
                            defaultSafeAreaMm: number;
                            /** @description The minimum print resolution, in dots per inch, a design's pictures are judged against when their template sets none. */
                            minPrintDpi: number;
                        };
                        /** @description Whether a newly rendered proof carries a watermark. */
                        proofWatermark: boolean;
                        /** @description Whether the store's address answered the test call made when it was approved. A sandbox store that did not (a local machine, a private address) is connected anyway, but webhooks and every other call Pixonaut makes to it will not arrive; reconnect once it can be reached. Always true for a live store, which is refused when it does not answer. */
                        reachable: boolean;
                        siteUrl: string;
                        tenantId: string;
                        /** @description The workspace's name. A sandbox is named after its live workspace. */
                        tenantName: string;
                        webhookEndpointId: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "connectedStore.delete": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The store was disconnected */
            204: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "connectedStore.update": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description Origins on hosts of the site's own registrable domain, by the Public Suffix List, with the site's scheme and port: for `https://example.com`, `https://www.example.com` or `https://checkout.example.com`. Each written as a browser's `Origin` header spells it, with no path and no wildcard. At most 10, listed after the site's own in the order given; an empty list takes them away. The site's own origin is always kept. Omitted, the origins stay as they are. */
                    additionalOrigins?: string[];
                    /** @description The brand the store's hosted pages are drawn in, one of `GET /v1/connect`'s `brands`, or null for the workspace's default. Omitted, the brand stays as it is. */
                    brandId?: string | null;
                };
            };
        };
        responses: {
            /** @description The store's connection */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description The publishable key's origins, the site's own first. */
                        allowedOrigins: string[];
                        /** @description Hours a customer upload nothing holds is kept: the workspace's retention, else the platform's default. */
                        assetTtlHours: number;
                        /** @description The brand chosen for this store, one of `brands`; null when it follows the workspace's default brand. */
                        brandId: string | null;
                        /** @description What the hosted pages the store sends customers to show. A link keeps the brand it was created in; a change applies to links created after it. */
                        branding: {
                            /** @description The colour the hosted pages are drawn in, as `#rrggbb`: an ink's screen colour while the accent is linked to one. null when none is set. */
                            accentColor: string | null;
                            /** @description The brand the store's hosted pages are drawn in now: its own, else the workspace's default. null only for a workspace with no brand yet. */
                            brandId: string | null;
                            /** @description An address the brand's logo loads from for a while; read the connection again for a fresh one. null when no logo is set. */
                            logoUrl: string | null;
                        };
                        /** @description The workspace's brands, the default first, then by name: what the store may choose with `PATCH /v1/connect`. */
                        brands: {
                            /** @description Its accent colour, as `branding.accentColor`. */
                            accentColor: string | null;
                            id: string;
                            /** @description Whether it is the workspace's default brand, which a store with no brand of its own is drawn in. */
                            isDefault: boolean;
                            /** @description An address its logo loads from for a while, as `branding.logoUrl`; null when it has none. */
                            logoUrl: string | null;
                            name: string;
                        }[];
                        connectionId: string;
                        /** @description The workspace's default language, one of `en`, `sv`, `de`, `fr`, `es`, `nl`, `da`, `nb`, `fi`: what its hosted pages and the designer are shown in when a link or a mount names no `locale`. English until the workspace chooses one. */
                        defaultLanguage: string;
                        /** @description The workspace's saved address every new order ships to instead of its customer. null when orders ship to their customer. */
                        deliverOrdersTo: {
                            id: string;
                            name: string;
                        } | null;
                        environment: string;
                        /** @description The integration key's name, which a member may have renamed in the studio. */
                        name: string;
                        /** @description The workspace's print defaults a template falls back to: its own, else the product's. */
                        printing: {
                            /** @description The bleed past the trim that artwork without a blank prints with, in millimetres. */
                            defaultBleedMm: number;
                            /** @description The safe area inside the trim, in millimetres, on the same terms as defaultBleedMm. */
                            defaultSafeAreaMm: number;
                            /** @description The minimum print resolution, in dots per inch, a design's pictures are judged against when their template sets none. */
                            minPrintDpi: number;
                        };
                        /** @description Whether a newly rendered proof carries a watermark. */
                        proofWatermark: boolean;
                        /** @description Whether the store's address answered the test call made when it was approved. A sandbox store that did not (a local machine, a private address) is connected anyway, but webhooks and every other call Pixonaut makes to it will not arrive; reconnect once it can be reached. Always true for a live store, which is refused when it does not answer. */
                        reachable: boolean;
                        siteUrl: string;
                        tenantId: string;
                        /** @description The workspace's name. A sandbox is named after its live workspace. */
                        tenantName: string;
                        webhookEndpointId: string;
                    };
                };
            };
            /** @description Refused: invalid_origin, too_many_origins, invalid_input */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `too_many_origins`. */
                        max?: number;
                        /** @description Always sent with `invalid_origin`. */
                        origin?: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found, brand_not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "memberLinks.delete": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The link was revoked */
            204: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Refused: unauthorized, member_link_required, member_link_revoked */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: forbidden, origin_forbidden, feature_disabled */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "connectedStore.exchangeCode": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    code: string;
                    code_verifier?: string;
                    /**
                     * @description Exchanges a member link's code, sent with the store's integration key as the bearer, for the approving member's member key. Left out, the code connects the store, and no bearer is read.
                     * @enum {string}
                     */
                    kind?: "member_link";
                    redirect_uri?: string;
                };
            };
        };
        responses: {
            /** @description What the store is given: its connection, or a member's link */
            201: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        connectionId: string;
                        environment: string;
                        integrationKey: {
                            id: string;
                            /** @description The integration key itself. Shown in this response only. */
                            key: string;
                            label: string;
                        };
                        /** @description The member who approved the connection, linked to the store: the member key for the user who connected it. */
                        memberKey: {
                            /** @description The member key (`mk_live_…`, or `mk_test_…` in a sandbox). Shown in this response only. */
                            key: string;
                            memberEmail: string | null;
                            memberId: string;
                            memberName: string | null;
                        };
                        publishableKey: {
                            allowedOrigins: string[];
                            id: string;
                            /** @description Shown in this response only. */
                            key: string;
                        };
                        /** @description Whether the store's address answered the test call made when it was approved. A sandbox store that did not (a local machine, a private address) is connected anyway, but webhooks and every other call Pixonaut makes to it will not arrive; reconnect once it can be reached. Always true for a live store, which is refused when it does not answer. */
                        reachable: boolean;
                        tenantId: string;
                        /** @description The workspace's name. A sandbox is named after its live workspace. */
                        tenantName: string;
                        webhook: {
                            id: string;
                            /** @description The endpoint's signing secret. Shown in this response only. */
                            secret: string;
                            url: string;
                        };
                    } | {
                        /** @description The member key (`mk_live_…`, or `mk_test_…` in a sandbox). Shown in this response only. */
                        key: string;
                        memberEmail: string | null;
                        memberId: string;
                        memberName: string | null;
                    };
                };
            };
            /** @description Refused: invalid_grant */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: plan_limit_reached, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The limit the tenant is at: `templates`, `connectedStores`, `apiKeys`, `shareLinks`, `customDomains`, `printsMadePerMonth` (prints made without an order this month), `members`, `orders` (this month's orders, which getting a print's files without an order counts as), or a sandbox's own caps: `sandboxPrintsPerDay`, `sandboxPrintsPerMonth`, `sandboxOrdersPerMonth`. A sandbox shares every other limit with its live workspace. Always sent with `plan_limit_reached`. */
                        limit?: string;
                        /** @description How many the plan allows. Always sent with `plan_limit_reached`. */
                        max?: number;
                        /** @description The plan whose limit it is. Always sent with `plan_limit_reached`. */
                        plan?: string;
                    };
                };
            };
            /** @description Refused: payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "designs.list": {
        parameters: {
            query?: {
                /** @description The page to read, from 1; the first when left out. */
                page?: number;
                pageSize?: number;
                /** @description Only designs in this status: `committed` waits for a decision, `approved` and `rejected` are decided. */
                status?: "committed" | "approved" | "rejected";
                /** @description Only designs whose template name, id or your own reference holds this text, case aside. */
                q?: string;
                /** @description Only designs received (`committed_at`) at or after this time, in epoch milliseconds. */
                receivedFrom?: number | null;
                /** @description Only designs received (`committed_at`) at or before this time, in epoch milliseconds. */
                receivedTo?: number | null;
                /** @description By when the designs were received: `desc`, newest first, unless `asc` asks for the oldest first. */
                order?: "asc" | "desc";
                template?: string;
                externalRef?: string;
                /** @description `true` lists only standing designs, `false` only the rest; left out, both. */
                standing?: "true" | "false";
                pageOf?: string;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description A page of designs */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description How many designs each status holds under the rest of the query: every filter but `status`, so the counts stay the same whichever status is asked for. */
                        counts: {
                            approved: number;
                            committed: number;
                            rejected: number;
                        };
                        designs: {
                            api_key_id: string | null;
                            approve_after: number | null;
                            approved_at: number | null;
                            approved_via: string | null;
                            /** @description Whether the customer's request for changes is open: `changeRequest` of `GET /v1/designs/{id}` is not null. */
                            change_requested: boolean;
                            committed_at: number;
                            /** @description Whether `DELETE /v1/designs/{id}` would take the design now: it is not approved, and no print of it exists, of any revision and in any status. */
                            deletable: boolean;
                            duplicated_from: string | null;
                            /** @description Your own reference for the design, as sent on the commit or `PUT /v1/designs/{id}/external-ref`, or null. */
                            external_ref: string | null;
                            /** @description Whether any print of the design has been ordered: `hasOrder` of `GET /v1/designs/{id}`. */
                            has_order: boolean;
                            /** @description Whether the design has a print file: a completed print of any of its revisions. Unlike `hasPrint` of `GET /v1/designs/{id}`, a print of an earlier revision counts. */
                            has_print_file: boolean;
                            id: string;
                            /** @description Where the design came from: the door it was committed through. A duplicate's is whoever duplicated it. */
                            origin: {
                                /** @description The designer link's id, the key's id, or the connected store's site address. Null for `studio`, and for a key set in the deployment's configuration rather than made in the workspace. */
                                id: string | null;
                                /** @description `link`: a designer link's page made it. `studio`: a member made it, in the studio or through an MCP key. `secret_key` and `publishable_key`: committed with one of your keys. `store`: committed by a connected store, with any key its site was given. */
                                kind: string;
                            };
                            /** @description The size the design prints at, without bleed: the `widthMm` and `heightMm` its proof or commit named, or the size fitted for one that named none. A store checks it, with `template_version`, `blank_id` and `placement_id`, against what the product variation sells before accepting the add to cart, since the proof is made in the customer's browser. Null only for a stored document that holds no usable print size. */
                            print_size: {
                                /** @description The print's trim height, in millimetres. */
                                heightMm: number;
                                /** @description The print's trim width, in millimetres. */
                                widthMm: number;
                            } | null;
                            proof_id: string | null;
                            proof_revision: number | null;
                            revision: number;
                            /** @description Whether this is a standing design: the workspace's own design for a fixed product, made by `POST /v1/designs/standing` from a template version as its author left it. A standing design is ordered any number of times, each order reusing the print of its current revision. False for a customer's design. */
                            standing: boolean;
                            status: string;
                            template_base_id: string;
                            /** @description Whether the design's template was deleted. The design keeps its template's name and version; the template itself can no longer be opened. */
                            template_deleted: boolean;
                            template_id: string;
                            template_name: string | null;
                            /** @description The version of the template the design was made from: `template_id` after its `@`. A design committed from a proof token was made from the proof's version, whatever the template's latest is now. */
                            template_version: number | null;
                        }[];
                        page: number;
                        pageSize: number;
                        total: number;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: invalid_query */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "designs.commit": {
        parameters: {
            query?: {
                /** @description The IANA timezone the template's dynamic values are resolved in, such as `Europe/Stockholm`: today's date there. Absent, the workspace's timezone. */
                tz?: string;
                /** @description The language the template's dynamic values are written in when their name names none, one of `en`, `sv`, `de`, `fr`, `es`, `nl`, `da`, `nb`, `fi`. Absent, the workspace's default language. A value whose name carries a language, `{date.long:sv}`, keeps it. */
                lang?: "en" | "sv" | "de" | "fr" | "es" | "nl" | "da" | "nb" | "fi";
            };
            header?: {
                /** @description Your own key for this request. A repeat with the same key and body within 24 hours is answered with what the first one made, marked `Idempotent-Replayed: true`, and makes nothing; the same key with another body is refused `idempotency_key_reused`, and a repeat while the first is still being answered `idempotency_key_in_use`. A request that is refused makes nothing, so its key may be sent again. */
                "idempotency-key"?: string;
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": ({
                    proofToken: string;
                } & {
                    /** @description The order data a printshop needs to fulfil this design, such as a material or a shipping method: a JSON object of your own keys, which Pixonaut keeps and hands on with the order without reading its keys. Its size and nesting depth are limited. Only a secret or integration key may send it, `null` included; a publishable key sending it is refused with `secret_key_required`. */
                    fulfilmentPayload?: unknown;
                } & {
                    /** @description The id of the printshop that makes this design's orders, for a design on no blank. A design on a blank is made by the blank's printshop, set when the blank was created: naming any other is refused with `printshop_differs_from_blank`, and the design keeps the blank's printshop even once the blank is deleted. Absent or `null`, a design on no blank goes to the tenant's default printshop as it is when the order is made. Only a secret or integration key may send it, `null` included; a publishable key sending it is refused with `secret_key_required`. */
                    printshopId?: string | null;
                } & {
                    /** @description Your own reference for this design, such as your cart or order line id: kept exactly as sent, not unique, and never read by Pixonaut. `GET /v1/designs?externalRef=` finds the designs holding it, and `PUT /v1/designs/{id}/external-ref` replaces it. Only a secret or integration key may send it; a publishable key sending it is refused with `secret_key_required`. */
                    externalRef?: string;
                } & {
                    /** @description Approve the design as it is committed, so it is never awaiting approval: an explicit approval by the caller, recorded as `design.approved`. Needs `designs:update`: a secret key and an integration key hold it, a member may, and a publishable key never does; a caller without it is refused with `forbidden`. Left out or `false`, the design waits for approval. */
                    approve?: boolean;
                }) | ({
                    templateId: string;
                    /** @description What the customer entered: an object keyed by the id of the template layer each value is for, holding that layer's properties (a text layer's `content`, for instance). Checked against the template when the design is committed. */
                    values?: unknown;
                } & {
                    blankId?: string;
                    placementId?: string;
                } & {
                    /** @description The linked group the placement is designed as part of: every placement one design drives, this one among them, each with whether its print is mirrored. The print is mirrored when this placement's entry says so, and a repeat on it is laid at one physical scale across the group: the document records the group and the width of its widest placement's print area (`linked.referenceWidthMm`). Needs `blankId` and `placementId`; each placement must be one of the blank's. */
                    linked?: {
                        /** @description Placements one design drives, two at least. */
                        placements: {
                            /** @description Whether the placement's print is mirrored left to right. */
                            mirror?: boolean;
                            /** @description The id of one of the blank's placements. */
                            placementId: string;
                        }[];
                    };
                    placementId?: string;
                } & {
                    /** @description The order data a printshop needs to fulfil this design, such as a material or a shipping method: a JSON object of your own keys, which Pixonaut keeps and hands on with the order without reading its keys. Its size and nesting depth are limited. Only a secret or integration key may send it, `null` included; a publishable key sending it is refused with `secret_key_required`. */
                    fulfilmentPayload?: unknown;
                } & {
                    /** @description The id of the printshop that makes this design's orders, for a design on no blank. A design on a blank is made by the blank's printshop, set when the blank was created: naming any other is refused with `printshop_differs_from_blank`, and the design keeps the blank's printshop even once the blank is deleted. Absent or `null`, a design on no blank goes to the tenant's default printshop as it is when the order is made. Only a secret or integration key may send it, `null` included; a publishable key sending it is refused with `secret_key_required`. */
                    printshopId?: string | null;
                } & {
                    /** @description Your own reference for this design, such as your cart or order line id: kept exactly as sent, not unique, and never read by Pixonaut. `GET /v1/designs?externalRef=` finds the designs holding it, and `PUT /v1/designs/{id}/external-ref` replaces it. Only a secret or integration key may send it; a publishable key sending it is refused with `secret_key_required`. */
                    externalRef?: string;
                } & {
                    /** @description Approve the design as it is committed, so it is never awaiting approval: an explicit approval by the caller, recorded as `design.approved`. Needs `designs:update`: a secret key and an integration key hold it, a member may, and a publishable key never does; a caller without it is refused with `forbidden`. Left out or `false`, the design waits for approval. */
                    approve?: boolean;
                } & {
                    heightMm?: number;
                    widthMm?: number;
                } & {
                    /** @description Whether the designer drew the customer's canvas at the template's own ratio, as the SDK mount option of that name sets it. The design is made at the chosen size through the template's fit either way, so this changes nothing in what is made. */
                    drawAtTemplateRatio?: boolean;
                } & {
                    /** @description A variant of the blank, by ref (`v_…`). On a blank whose print areas change with its size, the design is sized at, and keeps, that variant's size; a ref the blank has no variant of is refused with `variant_not_of_blank`. On any other blank it is not checked. A proof also keeps it as `proof_variant`, for display. */
                    variant?: string;
                    /** @description The size the design is for, as the blank's option values, such as `{"Size": "XL"}`, in place of `variant`: a value of each option the blank's print areas change with, and nothing else, or it is refused with `variant_row_invalid`. Ignored on a blank whose print areas change with nothing. */
                    variantRow?: {
                        [key: string]: string;
                    };
                } & {
                    /** @description Lays the design as a repeat of its template across the print area. Null, or absent, places it once. Through a designer link, a repeat the link offers, or null where its shopper may turn the repeat off; absent there, the link's own start. */
                    repeat?: {
                        /**
                         * @description How the tiles are laid: `grid` lines them up, `brick` moves every other row along by half a tile, `halfDrop` moves every other column down by half a tile, and `scatter` strews them at random places, turns and sizes, arranged by `seed`.
                         * @enum {string}
                         */
                        mode: "grid" | "brick" | "halfDrop" | "scatter";
                        /** @description Which arrangement a `scatter` draws: another seed is another arrangement of the same tile. Read by `scatter` only. */
                        seed: number;
                        /** @description The tile's width in percent of the print area's width, above 0 and at most 100; the tile keeps the template's shape. A tile that would print under 10 mm on a side is drawn at 10 mm. */
                        size: number;
                    } | null;
                });
            };
        };
        responses: {
            /** @description The committed design */
            201: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        designId: string;
                        /** @description The pictures that print below `printFloorDpi` at the design's print size. A warning: nothing is refused for it. */
                        lowResolution: {
                            /** @description The picture's pixels along the edge that decides. */
                            actualPx: number;
                            assetId: string;
                            /** @description Pixels per inch along that edge, as printed. */
                            effectiveDpi: number;
                            /** @description The layer the picture fills, or the artwork's own key for its image background. */
                            layerId: string;
                            /** @description The pixels that edge needs at the floor. */
                            minPx: number;
                        }[];
                        /** @description The minimum print resolution the design's pictures were judged against: the template's own, else the tenant's. */
                        printFloorDpi: number;
                    };
                };
            };
            /** @description Refused: placement_not_committable, print_size_not_committable, repeat_not_committable, bad_request, invalid_query */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `invalid_query`. */
                        reason?: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: secret_key_required, forbidden, origin_forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: unknown_proof, not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: proof_already_committed, correction_proof, layout_proof, idempotency_key_in_use */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Always sent with `proof_already_committed`. */
                        designId?: string;
                        error: string;
                    };
                };
            };
            /** @description Refused: proof_expired */
            410: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: idempotency_key_reused, invalid_idempotency_key, invalid_doc, invalid_fulfilment_payload, payload_too_large, missing_fulfilment_keys, spot_plate_required, unknown_printshop, printshop_disconnected, printshop_unavailable, printshop_differs_from_blank, constraint_violation, unknown_placement, variant_not_of_blank, variant_row_invalid, variant_required, asset_map_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Always sent with `variant_required`. */
                        areasVaryBy?: string[];
                        /** @description Always sent with `asset_map_too_large`, and may be sent with `payload_too_large`. */
                        bytes?: number;
                        /** @description Always sent with `spot_plate_required`. */
                        cause?: string;
                        /** @description Always sent with `invalid_doc`. */
                        detail?: unknown;
                        error: string;
                        /** @description Always sent with `payload_too_large`, `asset_map_too_large`. */
                        maxBytes?: number;
                        /** @description Always sent with `missing_fulfilment_keys`. */
                        missing?: string[];
                        /** @description Always sent with `unknown_printshop`, `printshop_disconnected`, `printshop_unavailable`, `printshop_differs_from_blank`, `variant_not_of_blank`, `variant_row_invalid`, `variant_required`. */
                        reason?: string;
                        /** @description Always sent with `spot_plate_required`. */
                        references?: string[];
                        /** @description Always sent with `variant_not_of_blank`. */
                        variant?: string;
                        /** @description Always sent with `constraint_violation`. */
                        violations?: {
                            /** @description On a `text_draws_fallback_glyphs` or `text_draws_missing_glyphs` warning: the characters the text's font cannot draw, each once, in the order the text first holds them. Absent on every other violation. */
                            characters?: string[];
                            given: unknown;
                            /** @description The language whose overrides break the rule, when only the template as it reads in that language does. Absent, the original. */
                            language?: string;
                            layerId: string;
                            prop: string;
                            rule: string;
                            /** @description `error` refuses a publish; `warning` is worth the author's attention and never does. */
                            severity: string;
                        }[];
                    };
                };
            };
            /** @description Refused: rate_limited, link_design_limit */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description When the link makes designs again: when the oldest design counted leaves the window. Null for a total limit. Always sent with `link_design_limit`. */
                        reopensAt?: number | null;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "designs.decide": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @enum {string} */
                    action: "approve";
                    /** @description Approve after this many days instead of now, 1 to 60: a window for the customer to change their mind. Left out, the design is approved now. */
                    afterDays?: number;
                    /** @description The designs to decide, at most 200, each named once. Their outcomes are answered in this order. */
                    designs: {
                        /** @description The design's `revision` as the caller read it. When the design has been corrected since, it is refused `revision_changed` with the revision it has now. */
                        expectedRevision: number;
                        id: string;
                    }[];
                } | {
                    /** @enum {string} */
                    action: "reject";
                    /** @description The designs to decide, at most 200, each named once. Their outcomes are answered in this order. */
                    designs: {
                        /** @description The design's `revision` as the caller read it. When the design has been corrected since, it is refused `revision_changed` with the revision it has now. */
                        expectedRevision: number;
                        id: string;
                    }[];
                    /** @description Why the designs are rejected, kept on each and carried by its `design.rejected` event, as `POST /v1/designs/{id}/reject` keeps it. */
                    reason?: string;
                };
            };
        };
        responses: {
            /** @description Each design's outcome */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        outcomes: ({
                            id: string;
                            /** @enum {boolean} */
                            ok: true;
                            status: string;
                        } | {
                            error: string;
                            id: string;
                            /** @enum {boolean} */
                            ok: false;
                            /** @description With `revision_changed`: the revision the design has now. */
                            revision?: number;
                        })[];
                    };
                };
            };
            /** @description Refused: bad_request */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "designs.commitThroughLayout": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description The caller's own reference, kept on every design made. */
                    externalRef?: string;
                    /** @description The token of the layout's proof the customer approved (`POST /v1/proofs/layout`): its canvas is cut as approved, at its blank, layout and size. A secret or integration key only. */
                    proofToken: string;
                } | {
                    blankId: string;
                    /** @description The caller's own reference, kept on every design made. */
                    externalRef?: string;
                    /** @description The name of the blank's panel layout the design is drawn on. */
                    layout: string;
                    /** @description Lays the design as a repeat of its template across the print area. Null, or absent, places it once. Through a designer link, a repeat the link offers, or null where its shopper may turn the repeat off; absent there, the link's own start. */
                    repeat?: {
                        /**
                         * @description How the tiles are laid: `grid` lines them up, `brick` moves every other row along by half a tile, `halfDrop` moves every other column down by half a tile, and `scatter` strews them at random places, turns and sizes, arranged by `seed`.
                         * @enum {string}
                         */
                        mode: "grid" | "brick" | "halfDrop" | "scatter";
                        /** @description Which arrangement a `scatter` draws: another seed is another arrangement of the same tile. Read by `scatter` only. */
                        seed: number;
                        /** @description The tile's width in percent of the print area's width, above 0 and at most 100; the tile keeps the template's shape. A tile that would print under 10 mm on a side is drawn at 10 mm. */
                        size: number;
                    } | null;
                    /** @description The published template version, `<baseId>@<version>`. */
                    templateId: string;
                    /** @description The customer's values, as on `POST /v1/designs`. */
                    values?: {
                        [key: string]: unknown;
                    };
                    /** @description A variant of the blank, by ref (`v_…`). On a blank whose print areas change with its size, the design is sized at, and keeps, that variant's size; a ref the blank has no variant of is refused with `variant_not_of_blank`. On any other blank it is not checked. A proof also keeps it as `proof_variant`, for display. */
                    variant?: string;
                    /** @description The size the design is for, as the blank's option values, such as `{"Size": "XL"}`, in place of `variant`: a value of each option the blank's print areas change with, and nothing else, or it is refused with `variant_row_invalid`. Ignored on a blank whose print areas change with nothing. */
                    variantRow?: {
                        [key: string]: string;
                    };
                };
            };
        };
        responses: {
            /** @description The designs made */
            201: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description One design per placement the layout has a window for, in the order of the layout's windows; the first is the lead. */
                        designs: {
                            designId: string;
                            /** @description The print's trim height, in millimetres. */
                            heightMm: number;
                            placementId: string;
                            /** @description The print's trim width, in millimetres. */
                            widthMm: number;
                        }[];
                        /** @description The pictures that print below `printFloorDpi` at the design's print size. A warning: nothing is refused for it. */
                        lowResolution: {
                            /** @description The picture's pixels along the edge that decides. */
                            actualPx: number;
                            assetId: string;
                            /** @description Pixels per inch along that edge, as printed. */
                            effectiveDpi: number;
                            /** @description The layer the picture fills, or the artwork's own key for its image background. */
                            layerId: string;
                            /** @description The pixels that edge needs at the floor. */
                            minPx: number;
                        }[];
                        /** @description The minimum print resolution the design's pictures were judged against: the template's own, else the tenant's. */
                        printFloorDpi: number;
                    };
                };
            };
            /** @description Refused: bad_request */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: secret_key_required, forbidden, origin_forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: unknown_proof, not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: layout_out_of_date, proof_already_committed, not_layout_proof */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Always sent with `proof_already_committed`. */
                        designId?: string;
                        error: string;
                        /** @description Always sent with `layout_out_of_date`. */
                        reason?: string;
                    };
                };
            };
            /** @description Refused: proof_expired */
            410: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: unknown_printshop, printshop_disconnected, printshop_unavailable, printshop_differs_from_blank, constraint_violation, unknown_placement, variant_not_of_blank, variant_row_invalid, variant_required, spot_plate_required, asset_map_too_large, unknown_layout, empty_layout, invalid_doc, payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Always sent with `variant_required`. */
                        areasVaryBy?: string[];
                        /** @description Always sent with `asset_map_too_large`, and may be sent with `payload_too_large`. */
                        bytes?: number;
                        /** @description Always sent with `spot_plate_required`. */
                        cause?: string;
                        /** @description Always sent with `invalid_doc`. */
                        detail?: unknown;
                        error: string;
                        /** @description Always sent with `asset_map_too_large`, `payload_too_large`. */
                        maxBytes?: number;
                        /** @description Always sent with `unknown_printshop`, `printshop_disconnected`, `printshop_unavailable`, `printshop_differs_from_blank`, `variant_not_of_blank`, `variant_row_invalid`, `variant_required`. */
                        reason?: string;
                        /** @description Always sent with `spot_plate_required`. */
                        references?: string[];
                        /** @description Always sent with `variant_not_of_blank`. */
                        variant?: string;
                        /** @description Always sent with `constraint_violation`. */
                        violations?: {
                            /** @description On a `text_draws_fallback_glyphs` or `text_draws_missing_glyphs` warning: the characters the text's font cannot draw, each once, in the order the text first holds them. Absent on every other violation. */
                            characters?: string[];
                            given: unknown;
                            /** @description The language whose overrides break the rule, when only the template as it reads in that language does. Absent, the original. */
                            language?: string;
                            layerId: string;
                            prop: string;
                            rule: string;
                            /** @description `error` refuses a publish; `warning` is worth the author's attention and never does. */
                            severity: string;
                        }[];
                    };
                };
            };
            /** @description Refused: rate_limited, link_design_limit */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description When the link makes designs again: when the oldest design counted leaves the window. Null for a total limit. Always sent with `link_design_limit`. */
                        reopensAt?: number | null;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "designs.findOrCreateStanding": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description Approve the design, made by this call or found not yet approved, recorded as `design.approved` like any other approval. Needs `designs:update` as well as `designs:create`; a caller without it is refused with `forbidden` and nothing is written. Left out or `false`, nothing is approved. */
                    approve?: boolean;
                    blankId?: string;
                    heightMm?: number;
                    /** @description The store's own name for the product the design is for, such as `product-123`: two products on one template version, blank, placement and size each keep their own standing design. Found only by the same key, from the same store. Left out, the design is the one every request naming no key finds. */
                    key?: string;
                    placementId?: string;
                    /** @description A layout adjustment's proof: the token a correction link handed out with `adjustLayout` answered for one of the caller's own standing designs of the same key, template version, blank, placement, size and row. The design is made from that proof's document, as a standing design of its own; the same proof again finds it, and the design it was laid out from is not changed. Any other proof is refused `not_a_layout_proof`, one of another key, placement, size or row `layout_proof_mismatch`, and one whose design was since rejected, deleted or erased `unknown_proof`. */
                    proofToken?: string;
                    /** @description The published template version, `<baseId>@<version>`. A base id without its version is refused with `template_version_required`. */
                    templateId: string;
                    /** @description A variant of the blank, by ref (`v_…`). On a blank whose print areas change with its size, the design is sized at, and keeps, that variant's size; a ref the blank has no variant of is refused with `variant_not_of_blank`. On any other blank it is not checked. A proof also keeps it as `proof_variant`, for display. */
                    variant?: string;
                    /** @description The size the design is for, as the blank's option values, such as `{"Size": "XL"}`, in place of `variant`: a value of each option the blank's print areas change with, and nothing else, or it is refused with `variant_row_invalid`. Ignored on a blank whose print areas change with nothing. */
                    variantRow?: {
                        [key: string]: string;
                    };
                    widthMm?: number;
                };
            };
        };
        responses: {
            /** @description The standing design found */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Whether the design is a layout adjustment's, made from `proofToken`, rather than the template version as its author left it. */
                        adjusted: boolean;
                        blankId: string | null;
                        /** @description Whether this call made the design; false when it found one. */
                        created: boolean;
                        designId: string;
                        /** @description The print's trim height, in millimetres. */
                        heightMm: number;
                        /** @description The store's key the request named; null for none. */
                        key: string | null;
                        placementId: string | null;
                        revision: number;
                        /** @enum {boolean} */
                        standing: true;
                        /** @description The design's status after the call: `approved` when approved by this call or before, else `committed`. */
                        status: string;
                        templateId: string;
                        /** @description The print's trim width, in millimetres. */
                        widthMm: number;
                    };
                };
            };
            /** @description The standing design made */
            201: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Whether the design is a layout adjustment's, made from `proofToken`, rather than the template version as its author left it. */
                        adjusted: boolean;
                        blankId: string | null;
                        /** @description Whether this call made the design; false when it found one. */
                        created: boolean;
                        designId: string;
                        /** @description The print's trim height, in millimetres. */
                        heightMm: number;
                        /** @description The store's key the request named; null for none. */
                        key: string | null;
                        placementId: string | null;
                        revision: number;
                        /** @enum {boolean} */
                        standing: true;
                        /** @description The design's status after the call: `approved` when approved by this call or before, else `committed`. */
                        status: string;
                        templateId: string;
                        /** @description The print's trim width, in millimetres. */
                        widthMm: number;
                    };
                };
            };
            /** @description Refused: template_version_required, bad_request */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: secret_key_required, forbidden, origin_forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: unknown_proof */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: proof_expired */
            410: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: spot_plate_required, unknown_printshop, printshop_disconnected, printshop_unavailable, printshop_differs_from_blank, constraint_violation, unknown_placement, variant_not_of_blank, variant_row_invalid, variant_required, not_a_layout_proof, layout_proof_mismatch, invalid_doc, payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Always sent with `variant_required`. */
                        areasVaryBy?: string[];
                        /** @description Sent with `payload_too_large`. */
                        bytes?: number;
                        /** @description Always sent with `spot_plate_required`. */
                        cause?: string;
                        /** @description Always sent with `invalid_doc`. */
                        detail?: unknown;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                        /** @description Always sent with `unknown_printshop`, `printshop_disconnected`, `printshop_unavailable`, `printshop_differs_from_blank`, `variant_not_of_blank`, `variant_row_invalid`, `variant_required`. */
                        reason?: string;
                        /** @description Always sent with `spot_plate_required`. */
                        references?: string[];
                        /** @description Always sent with `variant_not_of_blank`. */
                        variant?: string;
                        /** @description Always sent with `constraint_violation`. */
                        violations?: {
                            /** @description On a `text_draws_fallback_glyphs` or `text_draws_missing_glyphs` warning: the characters the text's font cannot draw, each once, in the order the text first holds them. Absent on every other violation. */
                            characters?: string[];
                            given: unknown;
                            /** @description The language whose overrides break the rule, when only the template as it reads in that language does. Absent, the original. */
                            language?: string;
                            layerId: string;
                            prop: string;
                            rule: string;
                            /** @description `error` refuses a publish; `warning` is worth the author's attention and never does. */
                            severity: string;
                        }[];
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "designs.get": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The design, with its resolved document */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        api_key_id: string | null;
                        /** @description How the customer agreed to the design's approval, made or scheduled, as its approver said; null when none was said. Correcting the design, asking for changes and rejecting it clear it with the approval. */
                        approval_consent: {
                            /** @description When the customer agreed, epoch milliseconds. */
                            at: number;
                            /** @description How the customer agreed: by adding the design to their cart, by ticking a box, on a proof page, by approving it again on your store after correcting it (`edit`), or by letting your store's own approval deadline pass (`deadline`). More kinds may be added. */
                            kind: string;
                            ref: string | null;
                        } | null;
                        approve_after: number | null;
                        approved_at: number | null;
                        approved_via: string | null;
                        blank_id: string | null;
                        /** @description Whether the caller may approve or reject designs: a secret key, or a member holding `designs:update`. */
                        canDecide: boolean;
                        /** @description Whether the caller may correct this design now: `editable`, and they may decide designs. */
                        canEdit: boolean;
                        /** @description The open request for changes a customer made on the design's proof page, or null. Open while the design awaits approval at the version it was about; correcting or deciding the design closes it. */
                        changeRequest: {
                            message: string;
                            requestedAt: number;
                        } | null;
                        /** @description What the design holds now for each field of `correctionForm`, in its order and with its labels: each text as it reads, each picture (an asset id) and each colour. What `choices` of its current revision says. Null when the form cannot be read. */
                        choices: ({
                            /** @description The form's label for the field. */
                            label: string;
                            /** @description The layer the choice is of, as the form names it. */
                            layerId: string;
                            /** @description The prop the form offered, such as `content`, `src` or `fill`. */
                            prop: string;
                            /** @enum {string} */
                            type: "text";
                            /** @description What the customer wrote. */
                            value: string;
                        } | {
                            /** @description The picture, an asset id; null when the image was left empty or the design's personal data was erased. */
                            assetId: string | null;
                            /** @description The form's label for the field. */
                            label: string;
                            /** @description The layer the choice is of, as the form names it. */
                            layerId: string;
                            /** @description The prop the form offered, such as `content`, `src` or `fill`. */
                            prop: string;
                            /** @enum {string} */
                            type: "image";
                        } | {
                            /** @description The colour as the design holds it. */
                            color?: unknown;
                            /** @description The form's label for the field. */
                            label: string;
                            /** @description The layer the choice is of, as the form names it. */
                            layerId: string;
                            /** @description The palette entry the customer picked; null for a colour of their own. */
                            name: string | null;
                            /** @description The prop the form offered, such as `content`, `src` or `fill`. */
                            prop: string;
                            /** @description What a screen shows the colour as, `#rrggbb`. */
                            swatch: string;
                            /** @enum {string} */
                            type: "color";
                        })[] | null;
                        committed_at: number;
                        /** @description The form a correction fills in: the design's template version's generated form, as the designer showed it to the customer. Served whether or not `canEdit`, since it also labels the texts of the design's revisions. Null when that version cannot be read. */
                        correctionForm: {
                            layout?: string;
                            steps: {
                                fields: {
                                    constraints: {
                                        [key: string]: unknown;
                                    };
                                    default?: unknown;
                                    description?: string;
                                    label: string;
                                    layerId: string;
                                    prop: string;
                                    type: string;
                                }[];
                                groupId: string;
                                index: number | null;
                                label: string;
                                layerIds: string[];
                                transforms: {
                                    layerId: string;
                                    transform: {
                                        [key: string]: unknown;
                                    };
                                }[];
                            }[];
                        } | null;
                        /** @description Whether `DELETE /v1/designs/{id}` would take the design now: it is not approved, and no print of it exists, of any revision and in any status. */
                        deletable: boolean;
                        doc: unknown;
                        duplicated_from: string | null;
                        /** @description Whether the design takes a correction now, whoever asks: it is not rejected and it has no order. */
                        editable: boolean;
                        /** @description Your own reference for the design, as sent on the commit or `PUT /v1/designs/{id}/external-ref`, or null. */
                        external_ref: string | null;
                        fulfilment_payload: unknown;
                        /** @description Whether any print of this design has been ordered. An ordered design takes no correction; duplicate it instead. */
                        hasOrder: boolean;
                        /** @description Whether the design's current text has been printed. A correction leaves that print showing the old text; it is never ordered, and the corrected design is printed again only when someone prints it once it is approved. */
                        hasPrint: boolean;
                        id: string;
                        /** @description The language the design was made in, one of `en`, `sv`, `de`, `fr`, `es`, `nl`, `da`, `nb`, `fi`: its template was read in it, with that language's overrides, and its document and print file are that language's. */
                        language: string;
                        /** @description Where the design came from: the door it was committed through. A duplicate's is whoever duplicated it. */
                        origin: {
                            /** @description The designer link's id, the key's id, or the connected store's site address. Null for `studio`, and for a key set in the deployment's configuration rather than made in the workspace. */
                            id: string | null;
                            /** @description `link`: a designer link's page made it. `studio`: a member made it, in the studio or through an MCP key. `secret_key` and `publishable_key`: committed with one of your keys. `store`: committed by a connected store, with any key its site was given. */
                            kind: string;
                        };
                        /** @description When the design's own personal data was erased (`POST /v1/designs/{id}/erase-personal-data`), or null. An erased design's document holds none of the text or pictures its customer put in, and nothing more is printed, ordered or corrected from it. */
                        personal_data_erased_at: number | null;
                        /** @description The placement on the blank this design was fitted to when it was made; null whenever blank_id is. Kept while the blank is, so it may name a placement since removed from the blank: the print box frozen into the document is what prints. */
                        placement_id: string | null;
                        /** @description The size the design prints at, without bleed: the `widthMm` and `heightMm` its proof or commit named, or the size fitted for one that named none. A store checks it, with `template_version`, `blank_id` and `placement_id`, against what the product variation sells before accepting the add to cart, since the proof is made in the customer's browser. Null only for a stored document that holds no usable print size. */
                        print_size: {
                            /** @description The print's trim height, in millimetres. */
                            heightMm: number;
                            /** @description The print's trim width, in millimetres. */
                            widthMm: number;
                        } | null;
                        proof_id: string | null;
                        proof_revision: number | null;
                        /** @description The variant of the blank the customer previewed the design's proof on, by ref, as `POST /v1/proofs` was sent it; null when it named none. For display only: an order names its own variant. */
                        proof_variant: string | null;
                        /** @description The view of the blank's placement the customer previewed the design's proof in, by id, as `POST /v1/proofs` was sent it; null when it named none. */
                        proof_view_id: string | null;
                        /** @description Why the design was rejected, as its rejection said (`reason` on `POST /v1/designs/{id}/reject`); null when it is not rejected, or was rejected without one. Its customer is shown it on the proof page. */
                        rejection_reason: string | null;
                        revision: number;
                        /** @description The share link whose page made the design: committed there, or from a proof it made. Null when no link made it. */
                        share_link_id: string | null;
                        /** @description Whether this is a standing design: the workspace's own design for a fixed product, made by `POST /v1/designs/standing` from a template version as its author left it. A standing design is ordered any number of times, each order reusing the print of its current revision. False for a customer's design. */
                        standing: boolean;
                        status: string;
                        template_base_id: string;
                        /** @description Whether the design's template was deleted. The design keeps its template's name and version; the template itself can no longer be opened. */
                        template_deleted: boolean;
                        template_id: string;
                        template_name: string | null;
                        /** @description The version of the template the design was made from: `template_id` after its `@`. A design committed from a proof token was made from the proof's version, whatever the template's latest is now. */
                        template_version: number | null;
                        tenant_id: string;
                        /** @description The size the design was made for, on a blank whose print areas change with its size: the blank's option values it was sized at, such as `{"Size": "XL"}`. An order of a variant of another size is refused with `variant_not_of_design_row`. Null on a blank whose print areas change with nothing, or on no blank. */
                        variant_row: {
                            [key: string]: string;
                        } | null;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "designs.delete": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The design was deleted */
            204: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: design_approved, design_printed */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
            /** @description Refused: lock_timeout */
            503: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
        };
    };
    "designs.update": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description The token `POST /v1/designs/{id}/correction-proofs` answered for this design. The design must still be at the revision the proof was made from. */
                    proofToken: string;
                } | {
                    /** @description The design's `revision` as the caller read it. When the design has been corrected since, the correction is refused `revision_changed`. */
                    expectedRevision: number;
                    /** @description What to change, in the shape a commit's `values` take: an object keyed by the `layerId` of a field of the design's correctionForm, each holding an object of that field's `prop` and its new value, such as `{"<layerId>": {"<prop>": "new wording"}}`. Applied on top of the design as it is, so anything not named stays as it was. */
                    values: {
                        [key: string]: unknown;
                    };
                };
            };
        };
        responses: {
            /** @description Corrected, and awaiting approval; or nothing to correct */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Whether this correction wrote a revision. False when it left the document as it was: nothing was written, the approval stands, and `revision` is the current one. */
                        edited: boolean;
                        /** @description The pictures that print below `printFloorDpi` at the design's print size. A warning: nothing is refused for it. */
                        lowResolution: {
                            /** @description The picture's pixels along the edge that decides. */
                            actualPx: number;
                            assetId: string;
                            /** @description Pixels per inch along that edge, as printed. */
                            effectiveDpi: number;
                            /** @description The layer the picture fills, or the artwork's own key for its image background. */
                            layerId: string;
                            /** @description The pixels that edge needs at the floor. */
                            minPx: number;
                        }[];
                        /** @description The minimum print resolution the design's pictures were judged against: the template's own, else the tenant's. */
                        printFloorDpi: number;
                        /** @description The design's proof now: the one rendered of the revision this wrote, or, when nothing was written, the proof the design already had (null when it has none). Its image is `GET /v1/designs/{id}/proof`. */
                        proofId: string | null;
                        revision: number;
                    };
                };
            };
            /** @description Refused: bad_request */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found, unknown_proof */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: not_editable, revision_changed, proof_not_for_design, proof_adjusts_layout */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description `ordered`: a print of the design has an order, so it is what was made; duplicate it instead. `erased`: the design's personal data was erased, and it takes nothing more. `cut_from_layout`: the design is one placement's print cut from a panel layout's canvas; commit a new design through the layout (`POST /v1/designs/layout`) instead. `linked`: the design is one placement's print of a linked group, which one design drives; commit the group's placements again instead. Always sent with `not_editable`. */
                        reason?: string;
                        /** @description Always sent with `revision_changed`. */
                        revision?: number;
                    };
                };
            };
            /** @description Refused: proof_expired */
            410: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: asset_map_too_large, constraint_violation, design_doc_unreadable, payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Always sent with `asset_map_too_large`, and may be sent with `payload_too_large`. */
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `asset_map_too_large`, `payload_too_large`. */
                        maxBytes?: number;
                        /** @description Always sent with `constraint_violation`. */
                        violations?: {
                            /** @description On a `text_draws_fallback_glyphs` or `text_draws_missing_glyphs` warning: the characters the text's font cannot draw, each once, in the order the text first holds them. Absent on every other violation. */
                            characters?: string[];
                            given: unknown;
                            /** @description The language whose overrides break the rule, when only the template as it reads in that language does. Absent, the original. */
                            language?: string;
                            layerId: string;
                            prop: string;
                            rule: string;
                            /** @description `error` refuses a publish; `warning` is worth the author's attention and never does. */
                            severity: string;
                        }[];
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description The caller left before the render started */
            499: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error, render_failed. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
            /** @description Refused: assets_unavailable, lock_timeout */
            503: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
        };
    };
    "designs.approve": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": {
                    /** @description Approve after this many days instead of now, 1 to 60: a window for the customer to change their mind. Left out, the design is approved now. */
                    afterDays?: number;
                    /** @description How the customer agreed to the design, kept on it (`approval_consent`) and in the approval's audit entry. Left out, none is kept. Through a deciding proof page link, refused `bad_request`: the link's approval records its own, a `proof_page` consent naming the link. */
                    consent?: {
                        /** @description When the customer agreed, epoch milliseconds. */
                        at: number;
                        /**
                         * @description How the customer agreed: by adding the design to their cart, by ticking a box, on a proof page, by approving it again on your store after correcting it (`edit`), or by letting your store's own approval deadline pass (`deadline`). More kinds may be added.
                         * @enum {string}
                         */
                        kind: "add_to_cart" | "checkbox" | "proof_page" | "edit" | "deadline";
                        /** @description Your own reference for the consent, such as the cart line or checkout it was given at. Through a proof page link, the link's id. */
                        ref?: string | null;
                    };
                    /** @description The design's `revision` as the caller read it. When the design has been corrected since, the decision is refused `revision_changed` with the revision it has now. Required through a proof page link: a customer decides the revision whose proof they were shown. */
                    expectedRevision?: number;
                } | null;
            };
        };
        responses: {
            /** @description Approved now, or scheduled to be */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        status: string;
                    };
                };
            };
            /** @description Refused: bad_request */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: not_committed, proof_outdated, revision_changed */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `revision_changed`. */
                        revision?: number;
                    };
                };
            };
            /** @description Refused: payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "designs.correctionLinks.create": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description Open a standing design for its layout alone, ordered or not: the designer moves and scales its printed layers within the plate and offers nothing else, and approving makes a layout adjustment's proof, whose token `POST /v1/designs/standing` makes a standing design of its own from. The design it was opened on is never changed. Refused `not_standing` for a design that is not a standing design. Left out or `false`, the link corrects the design. */
                    adjustLayout?: boolean;
                    /** @description The brand the link's page is drawn in: its name, logo and accent colour (`GET /v1/brands`). Refused `brand_not_found` unless it is one of the workspace's. Absent, a link a connected store's key hands out keeps the store's brand, and any other is drawn in whichever brand is the workspace's default when it opens. A brand a link that still opens names cannot be deleted. */
                    brandId?: string;
                    /** @description The workspace's own name for the link (`Spring market stand`), at most 80 characters, never shown on its page. Trimmed, inner spaces made one; empty is no name. Unique among the workspace's working links, case aside: one another holds is refused `share_link_name_taken` naming the holder, a longer one `share_link_name_too_long`. A withdrawn or expired link frees its name. */
                    name?: string;
                    /** @description Where the hosted correction page sends the customer back to: with `state` and the corrected proof's `proofToken` once they approve, with `state` alone when they cancel. Without it, the link is the SDK's credential only, and opens no page. On one of the origins the tenant's publishable keys are allowed on. */
                    returnUrl?: string;
                    /** @description Carried back to `returnUrl` untouched, for the store to match the customer to its own session. Only with `returnUrl`. */
                    state?: string;
                };
            };
        };
        responses: {
            /** @description The new link */
            201: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description The brand the link's page is drawn in; null for the workspace's default, whichever that is when it opens. */
                        brandId: string | null;
                        /** @description When the link stops working. */
                        expiresAt: number;
                        /** @description The link's id, as the share-link list names it. */
                        id: string;
                        /** @description The workspace's name for the link. */
                        name: string | null;
                        /** @description The link's token: the SDK's `correctionLink`. Shown in this response only. */
                        token: string;
                        /** @description The hosted correction page, when the link names a `returnUrl`; null otherwise. */
                        url: string | null;
                    };
                };
            };
            /** @description Refused: return_url_not_https, return_url_off_store, invalid_input */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: plan_limit_reached, origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                        /** @description The limit the tenant is at: `templates`, `connectedStores`, `apiKeys`, `shareLinks`, `customDomains`, `printsMadePerMonth` (prints made without an order this month), `members`, `orders` (this month's orders, which getting a print's files without an order counts as), or a sandbox's own caps: `sandboxPrintsPerDay`, `sandboxPrintsPerMonth`, `sandboxOrdersPerMonth`. A sandbox shares every other limit with its live workspace. Always sent with `plan_limit_reached`. */
                        limit?: string;
                        /** @description How many the plan allows. Always sent with `plan_limit_reached`. */
                        max?: number;
                        /** @description The plan whose limit it is. Always sent with `plan_limit_reached`. */
                        plan?: string;
                    };
                };
            };
            /** @description Refused: not_found, brand_not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: not_editable, share_link_name_taken, not_standing */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The link holding the name. Always sent with `share_link_name_taken`. */
                        holderId?: string | null;
                        /** @description `ordered`: a print of the design has an order, so it is what was made; duplicate it instead. `erased`: the design's personal data was erased, and it takes nothing more. `cut_from_layout`: the design is one placement's print cut from a panel layout's canvas; commit a new design through the layout (`POST /v1/designs/layout`) instead. `linked`: the design is one placement's print of a linked group, which one design drives; commit the group's placements again instead. Always sent with `not_editable`. */
                        reason?: string;
                    };
                };
            };
            /** @description Refused: share_link_name_too_long, payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Sent with `payload_too_large`. */
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                        /** @description The longest name a link may have. Always sent with `share_link_name_too_long`. */
                        maxLength?: number;
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
            /** @description Refused: lock_timeout */
            503: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
        };
    };
    "designs.correctionProofs.create": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description The design's `revision` as the caller read it. When the design has been corrected since, the correction is refused `revision_changed`. */
                    expectedRevision: number;
                    /** @description What to change, in the shape a commit's `values` take: an object keyed by the `layerId` of a field of the design's correctionForm, each holding an object of that field's `prop` and its new value, such as `{"<layerId>": {"<prop>": "new wording"}}`. Applied on top of the design as it is, so anything not named stays as it was. */
                    values: {
                        [key: string]: unknown;
                    };
                };
            };
        };
        responses: {
            /** @description The correction's proof */
            201: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        docHash: string;
                        /** @description When the proof and its token expire, in milliseconds since the Unix epoch. */
                        expiresAt: number;
                        /** @description The pictures that print below `printFloorDpi` at the design's print size. A warning: nothing is refused for it. */
                        lowResolution: {
                            /** @description The picture's pixels along the edge that decides. */
                            actualPx: number;
                            assetId: string;
                            /** @description Pixels per inch along that edge, as printed. */
                            effectiveDpi: number;
                            /** @description The layer the picture fills, or the artwork's own key for its image background. */
                            layerId: string;
                            /** @description The pixels that edge needs at the floor. */
                            minPx: number;
                        }[];
                        /** @description The minimum print resolution the design's pictures were judged against: the template's own, else the tenant's. */
                        printFloorDpi: number;
                        /** @description Redeemed by `PATCH /v1/designs/{id}` with a secret key or a connected store's integration key, to make this the design's next revision. */
                        proofToken: string;
                        /** @description The proof's image, for the customer to see. */
                        proofUrl: string;
                        /** @description The revision the proof was made from. */
                        revision: number;
                    };
                };
            };
            /** @description Refused: bad_request */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: not_editable, revision_changed, not_standing */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description `ordered`: a print of the design has an order, so it is what was made; duplicate it instead. `erased`: the design's personal data was erased, and it takes nothing more. `cut_from_layout`: the design is one placement's print cut from a panel layout's canvas; commit a new design through the layout (`POST /v1/designs/layout`) instead. `linked`: the design is one placement's print of a linked group, which one design drives; commit the group's placements again instead. Always sent with `not_editable`. */
                        reason?: string;
                        /** @description Always sent with `revision_changed`. */
                        revision?: number;
                    };
                };
            };
            /** @description Refused: asset_map_too_large, constraint_violation, design_doc_unreadable, payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Always sent with `asset_map_too_large`, and may be sent with `payload_too_large`. */
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `asset_map_too_large`, `payload_too_large`. */
                        maxBytes?: number;
                        /** @description Always sent with `constraint_violation`. */
                        violations?: {
                            /** @description On a `text_draws_fallback_glyphs` or `text_draws_missing_glyphs` warning: the characters the text's font cannot draw, each once, in the order the text first holds them. Absent on every other violation. */
                            characters?: string[];
                            given: unknown;
                            /** @description The language whose overrides break the rule, when only the template as it reads in that language does. Absent, the original. */
                            language?: string;
                            layerId: string;
                            prop: string;
                            rule: string;
                            /** @description `error` refuses a publish; `warning` is worth the author's attention and never does. */
                            severity: string;
                        }[];
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description The caller left before the render started */
            499: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error, render_failed. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
            /** @description Refused: assets_unavailable, lock_timeout */
            503: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
        };
    };
    "designs.delivery.get": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The design's delivery */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Whether a delivery given now still reaches the design's order: always while it is open; once it is ordered, while its open order's printshop takes address changes, or the order ships to a saved address, and the order is not past one. Never otherwise. */
                        changeable: boolean;
                        /** @description Who the design's first order is for and where it ships, while the design is open and one has been given; once it is ordered and `changeable`, who its open order is for and where it ships now. */
                        delivery: {
                            capturedAt: number;
                            recipient: {
                                /**
                                 * Format: email
                                 * @description The recipient's email address, for the carrier's notices.
                                 */
                                email?: string;
                                /** @description The recipient's name as a parcel label carries it, a person's or a company's. Up to 200 characters. */
                                name: string;
                                /** @description The recipient's phone number as the customer gave it, with the country code when it has one. */
                                phone?: string;
                            };
                            shippingAddress: {
                                /** @description The city or town. */
                                city: string;
                                /** @description The company of a business address, which the parcel goes to; the recipient is who receives it. */
                                company?: string;
                                /** @description The country as a two-letter ISO 3166-1 code in capitals, such as `SE` or `US`. */
                                country: string;
                                /** @description The first line of the street address: street and number. */
                                line1: string;
                                /** @description The second line of the address: an apartment, floor or c/o. */
                                line2?: string;
                                /** @description The postal code as the country writes it, such as `111 22` or `SW1A 1AA`. Left out where the country has none; a printshop that needs one refuses the order `postal_code_required`. */
                                postalCode?: string;
                                /** @description The state, province or county, where the country uses one. */
                                region?: string;
                            };
                        } | null;
                        /** @description Read through an address capture link bound to one order, once that order has shipped, will not be made (`failed`, `cancelled`) or its personal data was erased: which. Absent otherwise. */
                        orderClosed?: string;
                        /** @description `open` while the design takes a delivery; `ordered` once its first order has been placed, which took the delivery or went by its own request; `erased` once the design's personal data was erased; `rejected` once the design is rejected. */
                        state: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "designs.delivery.update": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    recipient: {
                        /**
                         * Format: email
                         * @description The recipient's email address, for the carrier's notices.
                         */
                        email?: string;
                        /** @description The recipient's name as a parcel label carries it, a person's or a company's. Up to 200 characters. */
                        name: string;
                        /** @description The recipient's phone number as the customer gave it, with the country code when it has one. */
                        phone?: string;
                    };
                    shippingAddress: {
                        /** @description The city or town. */
                        city: string;
                        /** @description The company of a business address, which the parcel goes to; the recipient is who receives it. */
                        company?: string;
                        /** @description The country as a two-letter ISO 3166-1 code in capitals, such as `SE` or `US`. */
                        country: string;
                        /** @description The first line of the street address: street and number. */
                        line1: string;
                        /** @description The second line of the address: an apartment, floor or c/o. */
                        line2?: string;
                        /** @description The postal code as the country writes it, such as `111 22` or `SW1A 1AA`. Left out where the country has none; a printshop that needs one refuses the order `postal_code_required`. */
                        postalCode?: string;
                        /** @description The state, province or county, where the country uses one. */
                        region?: string;
                    };
                };
            };
        };
        responses: {
            /** @description Given */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description When it was given. */
                        capturedAt: number;
                        /** @description What that order's printshop made of the change. */
                        delivery?: {
                            /** @description When the change was made. */
                            at: number;
                            /** @description What the printshop made of the change: `sending` while it is being told, `accepted`, `refused` (the order keeps the address the printshop has), or `carried` when what the printshop had not been sent yet carries the new address, so nothing extra was sent. */
                            state: string;
                            /** @description The printshop's own answer to a refused change; `null` otherwise. */
                            words: string | null;
                        } | null;
                        /** @description The open order it changed, once the design was ordered. */
                        orderId?: string;
                    };
                };
            };
            /** @description Refused: bad_request */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: design_ordered, design_erased, design_rejected, order_closed */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Always sent with `order_closed`. */
                        closed?: string;
                        error: string;
                    };
                };
            };
            /** @description Refused: postal_code_required, payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Sent with `payload_too_large`. */
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
            /** @description Refused: lock_timeout, address_change_unavailable */
            503: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `address_change_unavailable`. */
                        reason?: string;
                        /** @description Always sent with `address_change_unavailable`. */
                        retryable?: boolean;
                    };
                };
            };
        };
    };
    "designs.delivery.delete": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Erased, or there was none */
            204: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
            /** @description Refused: lock_timeout */
            503: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
        };
    };
    "designs.designer.get": {
        parameters: {
            query?: never;
            header?: {
                /** @description The SDK release making the request, which the SDK sends itself. A release that cannot draw the template is refused `sdk_outdated`; a request naming none is served. */
                "x-pixonaut-sdk-version"?: string;
            };
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The design and its template */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description The blank the design was fitted to when it was made, as `GET /v1/designs/{id}` answers `blank_id`; null for a design made on none. A designer opened on the design shows this blank's photos. */
                        blankId: string | null;
                        /** @description By palette name as `template.palettes` holds it, each colour's name in `lang` by its own name: what the designer shows under its swatch and lists as the field's value. Only the colours named in it; the rest read their own name, which a pick is held as in every language. */
                        colourNames?: {
                            [key: string]: {
                                [key: string]: string;
                            };
                        };
                        dieShapeId?: string;
                        /** @description The design's current document. */
                        doc: unknown;
                        /** @description The field keys of the fields a customer is offered: a value set on one is shown by any template with a field of the same key. */
                        fieldKeys: string[];
                        /** @description Each fixed text naming a field, such as `Happy birthday {field.name}`, by layer id, as runs: the template's text holds each field's default, and a designer writes the customer's value for each field into its runs, joining them as they are, never reading the result again. Absent when no text names a field. */
                        fieldTexts?: {
                            [key: string]: ({
                                literal: string;
                            } | {
                                /** @description Written in the field's place when its value is empty. */
                                fallback?: string;
                                field: string;
                            })[];
                        };
                        formSchema: {
                            layout?: string;
                            steps: {
                                fields: {
                                    constraints: {
                                        [key: string]: unknown;
                                    };
                                    default?: unknown;
                                    description?: string;
                                    label: string;
                                    layerId: string;
                                    prop: string;
                                    type: string;
                                }[];
                                groupId: string;
                                index: number | null;
                                label: string;
                                layerIds: string[];
                                transforms: {
                                    layerId: string;
                                    transform: {
                                        [key: string]: unknown;
                                    };
                                }[];
                            }[];
                        };
                        /** @description The language the template is read in, one of `en`, `sv`, `de`, `fr`, `es`, `nl`, `da`, `nb`, `fi`: `lang`, else the workspace's default. `template` is the original with that language's overrides (`localized`) merged in. */
                        language: string;
                        layerShapeIds?: {
                            [key: string]: string;
                        };
                        offeredShapes?: {
                            [key: string]: unknown;
                        };
                        /** @description Whether the customer's form offers anything to fill in or place: false when every layer is fixed or in no group, so a customer designing on it can change nothing. A store warns a merchant who sells a template meant to be filled in as a fixed product, or one that offers nothing as personalised. */
                        offersProperties: boolean;
                        optionLabels?: {
                            [key: string]: string;
                        };
                        /** @description Whether the designer offers the customer Pixel (`POST /v1/pixel/designer`): the template has Pixel for customers on and the workspace has not turned it off. A round may still be refused, as that route says. */
                        pixel: boolean;
                        /** @description The placement on `blankId` the design was fitted to; null whenever `blankId` is. */
                        placementId: string | null;
                        poweredBy: boolean;
                        previewUrl: string;
                        printFloorDpi: number;
                        printMargins: {
                            bleedMm: number;
                            safeAreaMm: number;
                        };
                        /** @description The revision `doc` is, which a correction made from it sends as `expectedRevision`. */
                        revision: number;
                        /** @description The template's showcases, by id and name: sets of example values its preview and mockup images are drawn with when their `showcase` names one, each with a link to its preview. Empty when it holds none. Their values are not served: the designer, a design, a proof and a print are drawn from `template` alone. */
                        showcases: {
                            id: string;
                            name: string;
                            /** @description A link to the preview drawn with this set, opening with no key for an hour or two, as `previewUrl` does the defaults'. */
                            previewUrl: string;
                        }[];
                        status: string;
                        template: components["schemas"]["ResolvedTemplate"];
                        /** @description The template's workspace's default language, one of `en`, `sv`, `de`, `fr`, `es`, `nl`, `da`, `nb`, `fi`: what the SDK designer is shown in when its mount names no `locale`. */
                        workspaceLanguage: string;
                    };
                };
            };
            /** @description Refused: sdk_version_invalid */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: not_editable, sdk_outdated, not_standing */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /**
                         * @description The first SDK release after the caller's that can draw the template, or null when no released SDK can yet. Always sent with `sdk_outdated`.
                         * @example 0.15.0
                         */
                        minimumSdkVersion?: string | null;
                        /** @description `ordered`: a print of the design has an order, so it is what was made; duplicate it instead. `erased`: the design's personal data was erased, and it takes nothing more. `cut_from_layout`: the design is one placement's print cut from a panel layout's canvas; commit a new design through the layout (`POST /v1/designs/layout`) instead. `linked`: the design is one placement's print of a linked group, which one design drives; commit the group's placements again instead. Always sent with `not_editable`. */
                        reason?: string;
                    };
                };
            };
            /** @description Refused: design_doc_unreadable, template_unreadable */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error, render_failed. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "designs.duplicate": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The new design */
            201: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        designId: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: design_erased */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
            /** @description Refused: lock_timeout */
            503: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
        };
    };
    "designs.erasePersonalData": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The design, its personal data erased */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        api_key_id: string | null;
                        /** @description How the customer agreed to the design's approval, made or scheduled, as its approver said; null when none was said. Correcting the design, asking for changes and rejecting it clear it with the approval. */
                        approval_consent: {
                            /** @description When the customer agreed, epoch milliseconds. */
                            at: number;
                            /** @description How the customer agreed: by adding the design to their cart, by ticking a box, on a proof page, by approving it again on your store after correcting it (`edit`), or by letting your store's own approval deadline pass (`deadline`). More kinds may be added. */
                            kind: string;
                            ref: string | null;
                        } | null;
                        approve_after: number | null;
                        approved_at: number | null;
                        approved_via: string | null;
                        blank_id: string | null;
                        committed_at: number;
                        /** @description Whether `DELETE /v1/designs/{id}` would take the design now: it is not approved, and no print of it exists, of any revision and in any status. */
                        deletable: boolean;
                        doc: unknown;
                        duplicated_from: string | null;
                        /** @description Your own reference for the design, as sent on the commit or `PUT /v1/designs/{id}/external-ref`, or null. */
                        external_ref: string | null;
                        fulfilment_payload: unknown;
                        id: string;
                        /** @description The language the design was made in, one of `en`, `sv`, `de`, `fr`, `es`, `nl`, `da`, `nb`, `fi`: its template was read in it, with that language's overrides, and its document and print file are that language's. */
                        language: string;
                        /** @description Where the design came from: the door it was committed through. A duplicate's is whoever duplicated it. */
                        origin: {
                            /** @description The designer link's id, the key's id, or the connected store's site address. Null for `studio`, and for a key set in the deployment's configuration rather than made in the workspace. */
                            id: string | null;
                            /** @description `link`: a designer link's page made it. `studio`: a member made it, in the studio or through an MCP key. `secret_key` and `publishable_key`: committed with one of your keys. `store`: committed by a connected store, with any key its site was given. */
                            kind: string;
                        };
                        /** @description When the design's own personal data was erased (`POST /v1/designs/{id}/erase-personal-data`), or null. An erased design's document holds none of the text or pictures its customer put in, and nothing more is printed, ordered or corrected from it. */
                        personal_data_erased_at: number | null;
                        /** @description The placement on the blank this design was fitted to when it was made; null whenever blank_id is. Kept while the blank is, so it may name a placement since removed from the blank: the print box frozen into the document is what prints. */
                        placement_id: string | null;
                        /** @description The size the design prints at, without bleed: the `widthMm` and `heightMm` its proof or commit named, or the size fitted for one that named none. A store checks it, with `template_version`, `blank_id` and `placement_id`, against what the product variation sells before accepting the add to cart, since the proof is made in the customer's browser. Null only for a stored document that holds no usable print size. */
                        print_size: {
                            /** @description The print's trim height, in millimetres. */
                            heightMm: number;
                            /** @description The print's trim width, in millimetres. */
                            widthMm: number;
                        } | null;
                        proof_id: string | null;
                        proof_revision: number | null;
                        /** @description The variant of the blank the customer previewed the design's proof on, by ref, as `POST /v1/proofs` was sent it; null when it named none. For display only: an order names its own variant. */
                        proof_variant: string | null;
                        /** @description The view of the blank's placement the customer previewed the design's proof in, by id, as `POST /v1/proofs` was sent it; null when it named none. */
                        proof_view_id: string | null;
                        /** @description Why the design was rejected, as its rejection said (`reason` on `POST /v1/designs/{id}/reject`); null when it is not rejected, or was rejected without one. Its customer is shown it on the proof page. */
                        rejection_reason: string | null;
                        revision: number;
                        /** @description The share link whose page made the design: committed there, or from a proof it made. Null when no link made it. */
                        share_link_id: string | null;
                        /** @description Whether this is a standing design: the workspace's own design for a fixed product, made by `POST /v1/designs/standing` from a template version as its author left it. A standing design is ordered any number of times, each order reusing the print of its current revision. False for a customer's design. */
                        standing: boolean;
                        status: string;
                        template_base_id: string;
                        /** @description Whether the design's template was deleted. The design keeps its template's name and version; the template itself can no longer be opened. */
                        template_deleted: boolean;
                        template_id: string;
                        template_name: string | null;
                        /** @description The version of the template the design was made from: `template_id` after its `@`. A design committed from a proof token was made from the proof's version, whatever the template's latest is now. */
                        template_version: number | null;
                        tenant_id: string;
                        /** @description The size the design was made for, on a blank whose print areas change with its size: the blank's option values it was sized at, such as `{"Size": "XL"}`. An order of a variant of another size is refused with `variant_not_of_design_row`. Null on a blank whose print areas change with nothing, or on no blank. */
                        variant_row: {
                            [key: string]: string;
                        } | null;
                    };
                };
            };
            /** @description The design was deleted, and is erased */
            204: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
            /** @description Refused: lock_timeout */
            503: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
        };
    };
    "designs.externalRef.update": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description Your own reference for the design, kept exactly as sent; `null` clears it. */
                    externalRef: string | null;
                };
            };
        };
        responses: {
            /** @description The design's reference */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        designId: string;
                        externalRef: string | null;
                    };
                };
            };
            /** @description Refused: bad_request */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "designs.mockup.get": {
        parameters: {
            query?: {
                /** @description A placement of the design's blank. Left out, the design's own. */
                placementId?: string;
                /** @description One of the placement's views. Left out, the view the design's proof was previewed in, else the placement's first view. */
                viewId?: string;
                /** @description A variant ref of the blank: the view's photo that shows it. Left out, the variant the design's proof was previewed on, else the view's default photo. */
                variant?: string;
                /** @description One of the placement's photos, by id, in place of a view and variant. */
                mockupId?: string;
                /** @description The long edge in pixels, clamped to the sizes the api renders. */
                size?: string;
                /** @description The design's `proof_id`. When it matches, the answer is cached `immutable`; when it names any other proof, it is refused `proof_changed`. */
                v?: string;
            };
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The design on the product photo */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "image/png": string;
                };
            };
            /** @description The caller's copy, named by its ETag, is current */
            304: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found, proof_not_found, proof_changed */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: mockup_rect_unusable, mockup_rect_outside_photo, mockup_placed_box_empty, photo_decode_failed, mockup_mesh_unusable, mockup_cut_unusable, mockup_mask_decode_failed, mockup_uv_decode_failed, mockup_uv_pass_mismatch, design_doc_unreadable, asset_map_too_large, invalid_query */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Always sent with `asset_map_too_large`. */
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `asset_map_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description The caller left before the render started */
            499: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: artwork_decode_failed, encode_failed, downscale_size_overflow, input_too_large, mockup_warp_unreadable, mockup_mesh_unreadable, mockup_cut_unreadable, mockup_uv_view_missing, composite_failed, db_error, render_failed. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
            /** @description Refused: asset_store_unavailable, assets_unavailable */
            503: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
        };
    };
    "designs.proof.get": {
        parameters: {
            query?: {
                /** @description The design's `proof_id`, which names bytes that never change. When it matches, the answer is cached `immutable`; when it names any other proof, it is refused `proof_changed`. */
                v?: string;
                /** @description The width in pixels the image is drawn at. The long edge served is derived from the image's own ratio, never larger than the stored image, and clamped to the sizes the api serves. */
                width?: string;
                /** @description `cover` when the image is cropped to fill its box: `width` is then its short edge. */
                fit?: "cover";
            };
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The proof image */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "image/jpeg": string;
                };
            };
            /** @description Not modified: the `If-None-Match` etag, the proof's id, still holds */
            304: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found, proof_not_found, proof_changed */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: invalid_query */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "designs.reject": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": {
                    /** @description The design's `revision` as the caller read it. When the design has been corrected since, the decision is refused `revision_changed` with the revision it has now. Required through a proof page link: a customer decides the revision whose proof they were shown. */
                    expectedRevision?: number;
                    /** @description Why the design is rejected, in your words: kept on the design, carried by its `design.rejected` event, and shown to its customer on the proof page. Trimmed; blank, over 500 characters, or holding a NUL or lone surrogate, is refused `bad_request`. A proof page link may not give one: that is refused `bad_request` too. */
                    reason?: string;
                } | null;
            };
        };
        responses: {
            /** @description Rejected */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @enum {boolean} */
                        ok: true;
                    };
                };
            };
            /** @description Refused: bad_request */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: not_committed, proof_outdated, revision_changed */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `revision_changed`. */
                        revision?: number;
                    };
                };
            };
            /** @description Refused: payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "designs.requestChanges": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description The design's `revision` as the caller read it. When the design has been corrected since, the decision is refused `revision_changed` with the revision it has now. Required through a proof page link: a customer decides the revision whose proof they were shown. */
                    expectedRevision?: number;
                    /** @description What should change, in the customer's words: kept on the design, and shown to whoever corrects it. */
                    message: string;
                };
            };
        };
        responses: {
            /** @description Recorded */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        revision: number;
                    };
                };
            };
            /** @description Refused: bad_request */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: design_erased, not_committed, proof_outdated, revision_changed */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `revision_changed`. */
                        revision?: number;
                    };
                };
            };
            /** @description Refused: payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "designs.review.get": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The design's review */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description When a scheduled approval falls due, or null. */
                        approveAfter: number | null;
                        /** @description Whether the caller may approve, reject or ask for changes: a secret key, or a proof page link the tenant handed the decision to. */
                        canDecide: boolean;
                        /** @description The open request for changes a customer made on the design's proof page, or null. Open while the design awaits approval at the version it was about; correcting or deciding the design closes it. */
                        changeRequest: {
                            message: string;
                            requestedAt: number;
                        } | null;
                        /** @description Whether the design has a proof image to show. */
                        hasProof: boolean;
                        id: string;
                        /** @description Whether the design has a proof and it shows what the design says now. Each correction renders a proof of its own; a design corrected before that was so has only its first proof. A customer decides the design from its proof page only when this is true. */
                        proofIsCurrent: boolean;
                        /** @description Why the design was rejected, as the shop said, for its customer to read; null when it is not rejected, or was rejected without a reason. */
                        rejectionReason: string | null;
                        revision: number;
                        status: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, secret_key_required, feature_disabled, forbidden */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "designs.revisions.list": {
        parameters: {
            query?: {
                pageSize?: number;
                /** @description Only revisions older than this one: a page's `nextBefore`. */
                before?: string;
            };
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description One page of the design's revisions, newest first */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description The `before` that reads the next older page; null when this page reaches revision 1. */
                        nextBefore: number | null;
                        revisions: {
                            createdAt: number;
                            /** @description The member who wrote it, named as they are now; null when no member did: a commit, a secret key's correction, or a revision that predates authorship. */
                            createdBy: {
                                name: string | null;
                            } | null;
                            /** @description Whether this revision is the design's document now. */
                            isCurrent: boolean;
                            /** @description Whether any print rendered this revision. */
                            printed: boolean;
                            revision: number;
                        }[];
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: invalid_query */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "designs.revisions.get": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
                /** @description A revision number. */
                revision: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The revision and its document */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description What the customer chose in this revision, as the template's form labels it; null when the form could not be read. */
                        choices: ({
                            /** @description The form's label for the field. */
                            label: string;
                            /** @description The layer the choice is of, as the form names it. */
                            layerId: string;
                            /** @description The prop the form offered, such as `content`, `src` or `fill`. */
                            prop: string;
                            /** @enum {string} */
                            type: "text";
                            /** @description What the customer wrote. */
                            value: string;
                        } | {
                            /** @description The picture, an asset id; null when the image was left empty or the design's personal data was erased. */
                            assetId: string | null;
                            /** @description The form's label for the field. */
                            label: string;
                            /** @description The layer the choice is of, as the form names it. */
                            layerId: string;
                            /** @description The prop the form offered, such as `content`, `src` or `fill`. */
                            prop: string;
                            /** @enum {string} */
                            type: "image";
                        } | {
                            /** @description The colour as the design holds it. */
                            color?: unknown;
                            /** @description The form's label for the field. */
                            label: string;
                            /** @description The layer the choice is of, as the form names it. */
                            layerId: string;
                            /** @description The palette entry the customer picked; null for a colour of their own. */
                            name: string | null;
                            /** @description The prop the form offered, such as `content`, `src` or `fill`. */
                            prop: string;
                            /** @description What a screen shows the colour as, `#rrggbb`. */
                            swatch: string;
                            /** @enum {string} */
                            type: "color";
                        })[] | null;
                        createdAt: number;
                        /** @description The member who wrote it, named as they are now; null when no member did: a commit, a secret key's correction, or a revision that predates authorship. */
                        createdBy: {
                            name: string | null;
                        } | null;
                        doc?: unknown;
                        /** @description Whether this revision is the design's document now. */
                        isCurrent: boolean;
                        revision: number;
                    };
                };
            };
            /** @description Refused: invalid_id */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "designs.revisions.image.get": {
        parameters: {
            query?: {
                /** @description `png` draws it as a PNG that keeps the design's transparency; absent or `jpeg`, the proof's JPEG. */
                format?: "jpeg" | "png";
                /** @description The width in pixels the drawing is shown at. Its long edge is derived from the design's declared ratio, and never larger than a proof's for a key; a studio session is drawn up to 4096 px. */
                width?: string;
                /** @description `cover` when the image is cropped to fill its box: `width` is then its short edge. */
                fit?: "cover";
            };
            header?: never;
            path: {
                id: string;
                /** @description A revision number. */
                revision: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The drawing */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "image/jpeg": string;
                    "image/png": string;
                };
            };
            /** @description Not modified: the `If-None-Match` etag still names this revision, its erasure, format and renderer */
            304: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Refused: invalid_id */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: design_doc_unreadable, asset_map_too_large, invalid_query */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Always sent with `asset_map_too_large`. */
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `asset_map_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error, render_failed. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
            /** @description Refused: assets_unavailable */
            503: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
        };
    };
    "designs.revisions.restore": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
                /** @description A revision number. */
                revision: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description The design's `revision` as the caller read it. When the design has been corrected since, the correction is refused `revision_changed`. */
                    expectedRevision: number;
                };
            };
        };
        responses: {
            /** @description The design's revision now */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description The design's proof now: the one rendered of the revision this wrote, or, when nothing was written, the proof the design already had (null when it has none). Its image is `GET /v1/designs/{id}/proof`. */
                        proofId: string | null;
                        /** @description Whether this restore wrote a revision. False when the named revision's document already was the current one: nothing was written, and `revision` is the current one. */
                        restored: boolean;
                        revision: number;
                    };
                };
            };
            /** @description Refused: bad_request, invalid_id */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: not_editable, revision_changed */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description `ordered`: a print of the design has an order, so it is what was made; duplicate it instead. `erased`: the design's personal data was erased, and it takes nothing more. `cut_from_layout`: the design is one placement's print cut from a panel layout's canvas; commit a new design through the layout (`POST /v1/designs/layout`) instead. `linked`: the design is one placement's print of a linked group, which one design drives; commit the group's placements again instead. Always sent with `not_editable`. */
                        reason?: string;
                        /** @description Always sent with `revision_changed`. */
                        revision?: number;
                    };
                };
            };
            /** @description Refused: asset_map_too_large, design_doc_unreadable, payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Always sent with `asset_map_too_large`, and may be sent with `payload_too_large`. */
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `asset_map_too_large`, `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description The caller left before the render started */
            499: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error, render_failed. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
            /** @description Refused: assets_unavailable, lock_timeout */
            503: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
        };
    };
    "events.list": {
        parameters: {
            query?: {
                /** @description The id of the last event the caller handled; the answer starts after it. Omitted, it starts at the tenant's first event. */
                after?: string;
                /** @description Comma-separated event types to narrow the answer to. Omitted, every type. */
                types?: string;
                /** @description The most events to answer. */
                limit?: number;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description A page of events */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description The events, in the order they were recorded, each in the envelope its type's webhook delivery carries, with the payload that type sends. */
                        events: (components["schemas"]["DesignCommittedEvent"] | components["schemas"]["DesignApprovalScheduledEvent"] | components["schemas"]["DesignApprovedEvent"] | components["schemas"]["DesignRejectedEvent"] | components["schemas"]["DesignDeletedEvent"] | components["schemas"]["DesignPersonalDataErasedEvent"] | components["schemas"]["DesignChangesRequestedEvent"] | components["schemas"]["DesignDeliveryCapturedEvent"] | components["schemas"]["DesignEditedEvent"] | components["schemas"]["DesignDuplicatedEvent"] | components["schemas"]["PrintCreatedEvent"] | components["schemas"]["PrintCompletedEvent"] | components["schemas"]["PrintFailedEvent"] | components["schemas"]["TemplatePublishedEvent"] | components["schemas"]["TemplateLiveChangedEvent"] | components["schemas"]["TemplateDeletedEvent"] | components["schemas"]["OrderCreatedEvent"] | components["schemas"]["OrderSubmittedEvent"] | components["schemas"]["OrderStatusChangedEvent"] | components["schemas"]["OrderFailedEvent"] | components["schemas"]["OrderCancelledEvent"] | components["schemas"]["OrderReroutedEvent"] | components["schemas"]["OrderDeliveryChangedEvent"] | components["schemas"]["OrderHeldEvent"] | components["schemas"]["OrderReleasedEvent"] | components["schemas"]["OrderTrackingAddedEvent"] | components["schemas"]["OrderTrackingChangedEvent"] | components["schemas"]["BlankDriftedEvent"] | components["schemas"]["BlankCreatedEvent"] | components["schemas"]["BlankUpdatedEvent"] | components["schemas"]["BlankDeletedEvent"] | components["schemas"]["BlankRestoredEvent"] | components["schemas"]["InkCreatedEvent"] | components["schemas"]["InkUpdatedEvent"] | components["schemas"]["InkDeletedEvent"] | components["schemas"]["PaletteCreatedEvent"] | components["schemas"]["PaletteUpdatedEvent"] | components["schemas"]["PaletteDeletedEvent"] | components["schemas"]["ShapeCreatedEvent"] | components["schemas"]["ShapeUpdatedEvent"] | components["schemas"]["ShapeDeletedEvent"] | components["schemas"]["AssetCreatedEvent"] | components["schemas"]["AssetUpdatedEvent"] | components["schemas"]["AssetDeletedEvent"] | components["schemas"]["PrintshopConnectedEvent"] | components["schemas"]["PrintshopDisconnectedEvent"] | components["schemas"]["PrintshopUpdatedEvent"] | components["schemas"]["PrintshopReconnectedEvent"] | components["schemas"]["PrintshopDeletedEvent"] | components["schemas"]["PrintshopRestoredEvent"] | components["schemas"]["RunStartedEvent"] | components["schemas"]["RunCompletedEvent"] | components["schemas"]["RunFailedEvent"] | components["schemas"]["RunExhaustedEvent"] | components["schemas"]["RunCancelledEvent"] | components["schemas"]["CreditsLowEvent"] | components["schemas"]["TextMessagesLowEvent"] | components["schemas"]["OrderBalanceEmptyEvent"] | components["schemas"]["ShareLinkRevokedEvent"] | components["schemas"]["ShareLinkRegeneratedEvent"])[];
                        /** @description Pass it as `after` for the next page. Null when nothing more is available yet: continue from the last event's id later. A pull looks through at most 1000 events, so with `types` a page can be short, or empty, with a cursor that still moves on. */
                        nextCursor: string | null;
                    };
                };
            };
            /** @description Refused: unknown_event, invalid_event_type */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `invalid_event_type`. */
                        type?: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, secret_key_required, feature_disabled, forbidden */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: invalid_query */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "mcp.request": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    id?: string | number | null;
                    /** @enum {string} */
                    jsonrpc: "2.0";
                    method?: string;
                    params?: {
                        [key: string]: unknown;
                    };
                } & {
                    [key: string]: unknown;
                };
            };
        };
        responses: {
            /** @description The JSON-RPC answer to one request */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        jsonrpc: string;
                    } & {
                        [key: string]: unknown;
                    };
                };
            };
            /** @description A notification, acknowledged */
            202: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description A body that is not JSON, or a protocol version this server does not speak, answered as a JSON-RPC error object */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: {
                            code: number;
                            data?: unknown;
                            message: string;
                        };
                        id: string | number | null;
                        jsonrpc: string;
                    };
                };
            };
            /** @description Refused: unauthorized, member_link_required, member_link_revoked */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "orders.list": {
        parameters: {
            query?: {
                /** @description The page to read, from 1; the first when left out. */
                page?: number;
                pageSize?: number;
                /** @description Only the orders of this print: its id, as list_prints returns it. The answer's total is then how many orders that print has. */
                printId?: string;
                designId?: string;
                externalRef?: string;
                /** @description Only the orders sent to this printshop connection: its id, as list_printshops returns it. */
                printshop?: string;
                /** @description Only the orders in any of these statuses: repeat it, or separate them with commas (`failed,outcome_unknown`). */
                status?: string | string[];
                /** @description Only the orders of this blank, whichever variant. */
                blankId?: string;
                /** @description Only the orders of this variant: its ref. */
                variant?: string;
                /** @description Only orders submitted at or after this time, in epoch milliseconds. */
                submittedFrom?: number | null;
                /** @description Only orders submitted at or before this time, in epoch milliseconds. */
                submittedTo?: number | null;
                /** @description Only the orders whose own reference, id or recipient's name starts with this text, case aside. Never logged. */
                q?: string;
                /** @description By when each order was `submitted` (the default) or last `updated`. */
                sort?: "submitted" | "updated";
                /** @description `desc`, the latest first, unless `asc` asks for the earliest. */
                order?: "asc" | "desc";
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description A page of orders */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description How many orders each status holds under every filter but `status`, every status named. */
                        counts: {
                            awaiting_prints?: number;
                            cancelled?: number;
                            failed?: number;
                            held?: number;
                            outcome_unknown?: number;
                            printed?: number;
                            queued?: number;
                            shipped?: number;
                            submitted?: number;
                        };
                        orders: {
                            adapter: string;
                            /** @description The blank `blankId` names, as it reads now; `null` as `blankId` is. */
                            blank: {
                                name: string;
                                /** @description Its option axes, in order: how a variant's `options` read, such as Color then Size. */
                                optionAxes: string[];
                                /** @description How many variants it has, retired ones included. */
                                variants: number;
                            } | null;
                            /** @description The blank the order's prints are on; `null` for prints on no blank, or an order placed before it was recorded. */
                            blankId: string | null;
                            /** @description The order's latest address change, made with `PATCH /v1/orders/{id}/delivery` after the order was sent; `null` for an order whose address never changed. */
                            delivery: {
                                /** @description When the change was made. */
                                at: number;
                                /** @description What the printshop made of the change: `sending` while it is being told, `accepted`, `refused` (the order keeps the address the printshop has), or `carried` when what the printshop had not been sent yet carries the new address, so nothing extra was sent. */
                                state: string;
                                /** @description The printshop's own answer to a refused change; `null` otherwise. */
                                words: string | null;
                            } | null;
                            /** @description The design the lead print was made from. */
                            designId: string;
                            externalOrderRef: string | null;
                            externalRef: string | null;
                            /** @description Why Pixonaut failed the order rather than its printshop, as a refusal code: `print_failed` (a print of it could not be made; `lastError` names it), `prints_timed_out` (its prints were not finished within three hours of placing it), or the refusal an order waiting for its prints met when it was handed on, such as `technique_not_offered`. `null` for an order its printshop refused, or one not failed. */
                            failureKind: string | null;
                            /** @description Why the order is `held`, while it is; `null` for an order not held. A held order is accepted and not handed to its printshop until the month resets with room for it or the workspace upgrades. */
                            hold: {
                                /** @description The plan's monthly order limit the order met. */
                                limit: number;
                                /** @description When the month resets (ISO 8601, UTC): the latest the order is released, if the new month has room for it. */
                                periodEnd: string;
                                /** @description Why it is held: `monthly_order_limit`, the workspace has placed the orders its plan includes this month. Show a reason you do not know as held without one, never as a failure. */
                                reason: string;
                            } | null;
                            id: string;
                            lastCheckedAt: number | null;
                            lastError: string | null;
                            personalDataErasedAt: number | null;
                            /** @description The order's lead print: the first of `printIds`, and the only one of an order of one print. */
                            printId: string;
                            /** @description Every print the order holds, the lead first: the prints of one item, each in its own placement on its blank. */
                            printIds: string[];
                            /** @description `printIds` with each print's design, placement and file. */
                            prints: ({
                                designId: string;
                                /** @description The revision of the design the print was made from: `GET /v1/designs/{id}/revisions/{revision}/image` draws it. */
                                designRevision: number;
                                /** @description The placement fields the printshop was sent for this print, from its position there; `null` for an order placed before they were recorded. */
                                placementFields: {
                                    name: string;
                                    /** @description Where the value came from: the variant's (or position's) own, the field's default, or nothing, sent empty. */
                                    source: string;
                                    value: string;
                                }[] | null;
                                /** @description The placement on its blank the print's design was committed for; `null` for a design with no blank, or one committed before placements were recorded. */
                                placementId: string | null;
                                printId: string;
                                /** @description Where on the item the print goes, by the name the order's printshop knows it by (its Printed as), recorded when the order was placed; `null` for a print on no blank, or an order placed before it was recorded. */
                                printedAs: string | null;
                                /** @description Which of this print's files the printshop was sent; `null` while the order waits for its prints (`awaiting_prints`). */
                                spotOutput: string | null;
                                /** @description Where the print has got to: `created` while it renders, which an order in `awaiting_prints` waits for, then `completed`, or `failed`. */
                                status: string;
                            } | {
                                /** @description A fill print is made from no design. */
                                designId: null;
                                /** @description A fill print: an optional placement of the blank the order left undesigned, printed flat in this colour (`#rrggbb`), its fill colour, at the placement's whole area. */
                                fillColour: string;
                                /** @description The placement fields the printshop was sent for this print, from its position there; `null` for an order placed before they were recorded. */
                                placementFields: {
                                    name: string;
                                    /** @description Where the value came from: the variant's (or position's) own, the field's default, or nothing, sent empty. */
                                    source: string;
                                    value: string;
                                }[] | null;
                                /** @description The placement on its blank the print's design was committed for; `null` for a design with no blank, or one committed before placements were recorded. */
                                placementId: string | null;
                                printId: string;
                                /** @description Where on the item the print goes, by the name the order's printshop knows it by (its Printed as), recorded when the order was placed; `null` for a print on no blank, or an order placed before it was recorded. */
                                printedAs: string | null;
                                /** @description Which of this print's files the printshop was sent; `null` while the order waits for its prints (`awaiting_prints`). */
                                spotOutput: string | null;
                                /** @description Where the print has got to: `created` while it renders, which an order in `awaiting_prints` waits for, then `completed`, or `failed`. */
                                status: string;
                            })[];
                            /** @description The printshop as it was when the order was placed: its name and kind (`adapter`). `null` for an order placed before it was recorded. */
                            printshopAsPlaced: {
                                adapter: string;
                                name: string;
                            } | null;
                            printshopConnectionId: string | null;
                            printshopName: string | null;
                            quantity: number;
                            /** @description Who the order is for: its customer. When `shipTo` is set, the order ships there and the customer is who it is finally for. */
                            recipient: {
                                /**
                                 * Format: email
                                 * @description The recipient's email address, for the carrier's notices.
                                 */
                                email?: string;
                                /** @description The recipient's name as a parcel label carries it, a person's or a company's. Up to 200 characters. */
                                name: string;
                                /** @description The recipient's phone number as the customer gave it, with the country code when it has one. */
                                phone?: string;
                            } | null;
                            /** @description The order submitted to replace this one, which names it as `replacesOrderId`; `null` for none. */
                            replacedByOrderId: string | null;
                            /** @description The failed order this one was submitted to replace; `null` for an order that replaces none. */
                            replacesOrderId: string | null;
                            /** @description The workspace's saved address the order ships to, as it was when the order was placed; `null` for an order that ships to its customer's address. Its printshop is handed this address, and erasing the order's personal data leaves it. */
                            shipTo: {
                                address: {
                                    /** @description The city or town. */
                                    city: string;
                                    /** @description The company of a business address, which the parcel goes to; the recipient is who receives it. */
                                    company?: string;
                                    /** @description The country as a two-letter ISO 3166-1 code in capitals, such as `SE` or `US`. */
                                    country: string;
                                    /** @description The first line of the street address: street and number. */
                                    line1: string;
                                    /** @description The second line of the address: an apartment, floor or c/o. */
                                    line2?: string;
                                    /** @description The postal code as the country writes it, such as `111 22` or `SW1A 1AA`. Left out where the country has none; a printshop that needs one refuses the order `postal_code_required`. */
                                    postalCode?: string;
                                    /** @description The state, province or county, where the country uses one. */
                                    region?: string;
                                };
                                /** @description What the address is called in the workspace, such as `Warehouse`: unique there, case aside, and the name a parcel sent there is addressed to. Up to 200 characters. */
                                name: string;
                                /** @description The saved address the order ships to, by id. It may have been changed or removed since; `name` and `address` are what the order was placed with. */
                                savedAddressId: string;
                            } | null;
                            /** @description The customer's address. Where the order ships, unless `shipTo` is set. */
                            shippingAddress: {
                                /** @description The city or town. */
                                city: string;
                                /** @description The company of a business address, which the parcel goes to; the recipient is who receives it. */
                                company?: string;
                                /** @description The country as a two-letter ISO 3166-1 code in capitals, such as `SE` or `US`. */
                                country: string;
                                /** @description The first line of the street address: street and number. */
                                line1: string;
                                /** @description The second line of the address: an apartment, floor or c/o. */
                                line2?: string;
                                /** @description The postal code as the country writes it, such as `111 22` or `SW1A 1AA`. Left out where the country has none; a printshop that needs one refuses the order `postal_code_required`. */
                                postalCode?: string;
                                /** @description The state, province or county, where the country uses one. */
                                region?: string;
                            } | null;
                            spotOutput: string | null;
                            status: string;
                            submittedAt: number;
                            tenantId: string;
                            tracking: {
                                /** @description Who carries it, such as `DHL`. */
                                carrier?: string;
                                /** @description The shipment's tracking number. */
                                number: string;
                                /**
                                 * Format: uri
                                 * @description Where the shipment is followed: an https address.
                                 */
                                url?: string;
                            } | null;
                            updatedAt: number;
                            /** @description The variant as it was when the order was placed: its options and the variant fields its printshop was sent. A later edit of the variant does not change it. */
                            variant: {
                                /** @description Each declared field, in the printshop's order, as it was sent. */
                                fields: {
                                    name: string;
                                    /** @description Where the value came from: the variant's (or position's) own, the field's default, or nothing, sent empty. */
                                    source: string;
                                    value: string;
                                }[];
                                options: {
                                    [key: string]: string;
                                };
                                ref: string;
                            } | null;
                            /** @description The variant the order names; `null` as `blankId` is. */
                            variantRef: string | null;
                        }[];
                        page: number;
                        pageSize: number;
                        total: number;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: invalid_query */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "orders.create": {
        parameters: {
            query?: never;
            header?: {
                /** @description Your own key for this request. A repeat with the same key and body within 24 hours is answered with what the first one made, marked `Idempotent-Replayed: true`, and makes nothing; the same key with another body is refused `idempotency_key_reused`, and a repeat while the first is still being answered `idempotency_key_in_use`. A request that is refused makes nothing, so its key may be sent again. */
                "idempotency-key"?: string;
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description The designs of one item in place of its prints, each an approved design of one side, committed on the same blank in a placement of its own; the first is the order's lead. The order makes a new print of each, as `POST /v1/prints` would, and waits for them; a standing design's order reuses the print of its current revision, completed or still rendering, and makes one only when there is none or it failed. Name `prints` or `designs`, not both. */
                    designs?: {
                        /** @description One approved design of the item, by the id `GET /v1/designs` answers. */
                        designId: string;
                    }[];
                    /** @description The caller's own reference for this order, such as its order id in the shop. Kept exactly as sent and handed to the printshop. */
                    externalRef?: string;
                    /** @description The prints of one item, each a print of a design committed on the same blank in a placement of its own, completed or still rendering; the first is the order's lead, which `printId` names on the order. One print places the order `POST /v1/prints/{id}/orders` would. Name `prints` or `designs`, not both. */
                    prints?: {
                        /** @description One print of the item, by the id `GET /v1/prints` answers. */
                        printId: string;
                    }[];
                    /** @description The printshop to make this order, for a print with no blank whose design named none when it was committed. A print on a blank is made by the blank's printshop: naming another is refused with `printshop_differs_from_blank`, and naming the blank's own as an unknown field. Absent or `null`, a print with no blank goes to the printshop its design was committed with, else the tenant's default. */
                    printshopId?: string | null;
                    /**
                     * @description How many copies to order. A whole number of 1 or more; 1 when left out.
                     * @default 1
                     */
                    quantity?: number;
                    /** @description Who the order is for. Left out, the first order of a design takes what its customer gave. */
                    recipient?: {
                        /**
                         * Format: email
                         * @description The recipient's email address, for the carrier's notices.
                         */
                        email?: string;
                        /** @description The recipient's name as a parcel label carries it, a person's or a company's. Up to 200 characters. */
                        name: string;
                        /** @description The recipient's phone number as the customer gave it, with the country code when it has one. */
                        phone?: string;
                    };
                    /** @description Order the design again on purpose. A design has one live order (in any status but `failed` and `cancelled`): absent or false, an order of a design that has one is refused `409 design_already_ordered`, naming the design and its newest live order, and nothing is written. True places the order whatever orders the design has. */
                    reorder?: boolean;
                    /** @description A saved address to ship to; the customer stays the recipient. null: the customer's. Left out: the workspace's setting. */
                    shipToAddressId?: string | null;
                    /** @description Where the order ships. Left out, the first order of a design takes what its customer gave. */
                    shippingAddress?: {
                        /** @description The city or town. */
                        city: string;
                        /** @description The company of a business address, which the parcel goes to; the recipient is who receives it. */
                        company?: string;
                        /** @description The country as a two-letter ISO 3166-1 code in capitals, such as `SE` or `US`. */
                        country: string;
                        /** @description The first line of the street address: street and number. */
                        line1: string;
                        /** @description The second line of the address: an apartment, floor or c/o. */
                        line2?: string;
                        /** @description The postal code as the country writes it, such as `111 22` or `SW1A 1AA`. Left out where the country has none; a printshop that needs one refuses the order `postal_code_required`. */
                        postalCode?: string;
                        /** @description The state, province or county, where the country uses one. */
                        region?: string;
                    };
                    /** @description The variant of the print's blank the order is for, by ref (`v_…`). Left out, a blank with exactly one variant orders that one, and one with several is refused `variant_required`. A ref of another blank is refused `variant_not_of_blank`, and a retired one `variant_retired`. The order keeps a copy of the variant as it was: its options and the printshop fields it was sent. */
                    variant?: string;
                };
            };
        };
        responses: {
            /** @description The placed order */
            201: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        adapter: string;
                        /** @description The blank `blankId` names, as it reads now; `null` as `blankId` is. */
                        blank: {
                            name: string;
                            /** @description Its option axes, in order: how a variant's `options` read, such as Color then Size. */
                            optionAxes: string[];
                            /** @description How many variants it has, retired ones included. */
                            variants: number;
                        } | null;
                        /** @description The blank the order's prints are on; `null` for prints on no blank, or an order placed before it was recorded. */
                        blankId: string | null;
                        /** @description The order's latest address change, made with `PATCH /v1/orders/{id}/delivery` after the order was sent; `null` for an order whose address never changed. */
                        delivery: {
                            /** @description When the change was made. */
                            at: number;
                            /** @description What the printshop made of the change: `sending` while it is being told, `accepted`, `refused` (the order keeps the address the printshop has), or `carried` when what the printshop had not been sent yet carries the new address, so nothing extra was sent. */
                            state: string;
                            /** @description The printshop's own answer to a refused change; `null` otherwise. */
                            words: string | null;
                        } | null;
                        /** @description The design the lead print was made from. */
                        designId: string;
                        externalOrderRef: string | null;
                        externalRef: string | null;
                        /** @description Why Pixonaut failed the order rather than its printshop, as a refusal code: `print_failed` (a print of it could not be made; `lastError` names it), `prints_timed_out` (its prints were not finished within three hours of placing it), or the refusal an order waiting for its prints met when it was handed on, such as `technique_not_offered`. `null` for an order its printshop refused, or one not failed. */
                        failureKind: string | null;
                        /** @description Why the order is `held`, while it is; `null` for an order not held. A held order is accepted and not handed to its printshop until the month resets with room for it or the workspace upgrades. */
                        hold: {
                            /** @description The plan's monthly order limit the order met. */
                            limit: number;
                            /** @description When the month resets (ISO 8601, UTC): the latest the order is released, if the new month has room for it. */
                            periodEnd: string;
                            /** @description Why it is held: `monthly_order_limit`, the workspace has placed the orders its plan includes this month. Show a reason you do not know as held without one, never as a failure. */
                            reason: string;
                        } | null;
                        id: string;
                        lastCheckedAt: number | null;
                        lastError: string | null;
                        personalDataErasedAt: number | null;
                        /** @description The order's lead print: the first of `printIds`, and the only one of an order of one print. */
                        printId: string;
                        /** @description Every print the order holds, the lead first: the prints of one item, each in its own placement on its blank. */
                        printIds: string[];
                        /** @description `printIds` with each print's design, placement and file. */
                        prints: ({
                            designId: string;
                            /** @description The revision of the design the print was made from: `GET /v1/designs/{id}/revisions/{revision}/image` draws it. */
                            designRevision: number;
                            /** @description The placement fields the printshop was sent for this print, from its position there; `null` for an order placed before they were recorded. */
                            placementFields: {
                                name: string;
                                /** @description Where the value came from: the variant's (or position's) own, the field's default, or nothing, sent empty. */
                                source: string;
                                value: string;
                            }[] | null;
                            /** @description The placement on its blank the print's design was committed for; `null` for a design with no blank, or one committed before placements were recorded. */
                            placementId: string | null;
                            printId: string;
                            /** @description Where on the item the print goes, by the name the order's printshop knows it by (its Printed as), recorded when the order was placed; `null` for a print on no blank, or an order placed before it was recorded. */
                            printedAs: string | null;
                            /** @description Which of this print's files the printshop was sent; `null` while the order waits for its prints (`awaiting_prints`). */
                            spotOutput: string | null;
                            /** @description Where the print has got to: `created` while it renders, which an order in `awaiting_prints` waits for, then `completed`, or `failed`. */
                            status: string;
                        } | {
                            /** @description A fill print is made from no design. */
                            designId: null;
                            /** @description A fill print: an optional placement of the blank the order left undesigned, printed flat in this colour (`#rrggbb`), its fill colour, at the placement's whole area. */
                            fillColour: string;
                            /** @description The placement fields the printshop was sent for this print, from its position there; `null` for an order placed before they were recorded. */
                            placementFields: {
                                name: string;
                                /** @description Where the value came from: the variant's (or position's) own, the field's default, or nothing, sent empty. */
                                source: string;
                                value: string;
                            }[] | null;
                            /** @description The placement on its blank the print's design was committed for; `null` for a design with no blank, or one committed before placements were recorded. */
                            placementId: string | null;
                            printId: string;
                            /** @description Where on the item the print goes, by the name the order's printshop knows it by (its Printed as), recorded when the order was placed; `null` for a print on no blank, or an order placed before it was recorded. */
                            printedAs: string | null;
                            /** @description Which of this print's files the printshop was sent; `null` while the order waits for its prints (`awaiting_prints`). */
                            spotOutput: string | null;
                            /** @description Where the print has got to: `created` while it renders, which an order in `awaiting_prints` waits for, then `completed`, or `failed`. */
                            status: string;
                        })[];
                        /** @description The printshop as it was when the order was placed: its name and kind (`adapter`). `null` for an order placed before it was recorded. */
                        printshopAsPlaced: {
                            adapter: string;
                            name: string;
                        } | null;
                        printshopConnectionId: string | null;
                        printshopName: string | null;
                        quantity: number;
                        /** @description Who the order is for: its customer. When `shipTo` is set, the order ships there and the customer is who it is finally for. */
                        recipient: {
                            /**
                             * Format: email
                             * @description The recipient's email address, for the carrier's notices.
                             */
                            email?: string;
                            /** @description The recipient's name as a parcel label carries it, a person's or a company's. Up to 200 characters. */
                            name: string;
                            /** @description The recipient's phone number as the customer gave it, with the country code when it has one. */
                            phone?: string;
                        } | null;
                        /** @description The order submitted to replace this one, which names it as `replacesOrderId`; `null` for none. */
                        replacedByOrderId: string | null;
                        /** @description The failed order this one was submitted to replace; `null` for an order that replaces none. */
                        replacesOrderId: string | null;
                        /** @description The workspace's saved address the order ships to, as it was when the order was placed; `null` for an order that ships to its customer's address. Its printshop is handed this address, and erasing the order's personal data leaves it. */
                        shipTo: {
                            address: {
                                /** @description The city or town. */
                                city: string;
                                /** @description The company of a business address, which the parcel goes to; the recipient is who receives it. */
                                company?: string;
                                /** @description The country as a two-letter ISO 3166-1 code in capitals, such as `SE` or `US`. */
                                country: string;
                                /** @description The first line of the street address: street and number. */
                                line1: string;
                                /** @description The second line of the address: an apartment, floor or c/o. */
                                line2?: string;
                                /** @description The postal code as the country writes it, such as `111 22` or `SW1A 1AA`. Left out where the country has none; a printshop that needs one refuses the order `postal_code_required`. */
                                postalCode?: string;
                                /** @description The state, province or county, where the country uses one. */
                                region?: string;
                            };
                            /** @description What the address is called in the workspace, such as `Warehouse`: unique there, case aside, and the name a parcel sent there is addressed to. Up to 200 characters. */
                            name: string;
                            /** @description The saved address the order ships to, by id. It may have been changed or removed since; `name` and `address` are what the order was placed with. */
                            savedAddressId: string;
                        } | null;
                        /** @description The customer's address. Where the order ships, unless `shipTo` is set. */
                        shippingAddress: {
                            /** @description The city or town. */
                            city: string;
                            /** @description The company of a business address, which the parcel goes to; the recipient is who receives it. */
                            company?: string;
                            /** @description The country as a two-letter ISO 3166-1 code in capitals, such as `SE` or `US`. */
                            country: string;
                            /** @description The first line of the street address: street and number. */
                            line1: string;
                            /** @description The second line of the address: an apartment, floor or c/o. */
                            line2?: string;
                            /** @description The postal code as the country writes it, such as `111 22` or `SW1A 1AA`. Left out where the country has none; a printshop that needs one refuses the order `postal_code_required`. */
                            postalCode?: string;
                            /** @description The state, province or county, where the country uses one. */
                            region?: string;
                        } | null;
                        spotOutput: string | null;
                        status: string;
                        submittedAt: number;
                        tenantId: string;
                        tracking: {
                            /** @description Who carries it, such as `DHL`. */
                            carrier?: string;
                            /** @description The shipment's tracking number. */
                            number: string;
                            /**
                             * Format: uri
                             * @description Where the shipment is followed: an https address.
                             */
                            url?: string;
                        } | null;
                        updatedAt: number;
                        /** @description The variant as it was when the order was placed: its options and the variant fields its printshop was sent. A later edit of the variant does not change it. */
                        variant: {
                            /** @description Each declared field, in the printshop's order, as it was sent. */
                            fields: {
                                name: string;
                                /** @description Where the value came from: the variant's (or position's) own, the field's default, or nothing, sent empty. */
                                source: string;
                                value: string;
                            }[];
                            options: {
                                [key: string]: string;
                            };
                            ref: string;
                        } | null;
                        /** @description The variant the order names; `null` as `blankId` is. */
                        variantRef: string | null;
                    };
                };
            };
            /** @description Refused: bad_request */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: plan_limit_reached, origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                        /** @description The limit the tenant is at: `templates`, `connectedStores`, `apiKeys`, `shareLinks`, `customDomains`, `printsMadePerMonth` (prints made without an order this month), `members`, `orders` (this month's orders, which getting a print's files without an order counts as), or a sandbox's own caps: `sandboxPrintsPerDay`, `sandboxPrintsPerMonth`, `sandboxOrdersPerMonth`. A sandbox shares every other limit with its live workspace. Always sent with `plan_limit_reached`. */
                        limit?: string;
                        /** @description How many the plan allows. Always sent with `plan_limit_reached`. */
                        max?: number;
                        /** @description The plan whose limit it is. Always sent with `plan_limit_reached`. */
                        plan?: string;
                    };
                };
            };
            /** @description Refused: print_not_found, design_not_found, not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: print_not_completed, print_needs_printshop, print_ticket_stale, print_superseded, print_files_deleted, design_erased, stale_update, design_already_ordered, printshop_paused, design_not_approved, idempotency_key_in_use */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Always sent with `stale_update`. */
                        current?: number;
                        /** @description Always sent with `design_already_ordered`. */
                        designId?: string;
                        /** @description Always sent with `print_ticket_stale`. */
                        detail?: string;
                        error: string;
                        /** @description Always sent with `design_already_ordered`. */
                        orderId?: string;
                        /** @description Always sent with `printshop_paused`. */
                        reason?: string;
                        /** @description Always sent with `print_not_completed`. */
                        status?: string;
                    };
                };
            };
            /** @description Refused: unknown_printshop, printshop_disconnected, printshop_unavailable, printshop_differs_from_blank, missing_fulfilment_keys, postal_code_required, saved_address_not_found, spot_plate_required, print_profile_unavailable, print_exceeds_position, print_not_position_size, print_exceeds_machine, print_raster_too_large, technique_not_offered, placement_unfilled, variant_not_of_blank, variant_retired, variant_required, field_value_missing, variant_not_of_design_row, print_without_placement, mixed_blanks, duplicate_placement, print_committed_elsewhere, printshop_cannot_combine, prints_disagree, idempotency_key_reused, invalid_idempotency_key, payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Sent with `payload_too_large`. */
                        bytes?: number;
                        /** @description Always sent with `spot_plate_required`. */
                        cause?: string;
                        /** @description Always sent with `variant_not_of_design_row`. */
                        designId?: string;
                        /** @description Always sent with `print_profile_unavailable`. */
                        detail?: string;
                        error: string;
                        /** @description Always sent with `field_value_missing`. */
                        field?: string;
                        /** @description Always sent with `field_value_missing`. */
                        fieldKind?: string;
                        /** @description Always sent with `prints_disagree`. */
                        key?: string;
                        /** @description Always sent with `print_exceeds_position`. */
                        largestMm?: {
                            heightMm: number;
                            widthMm: number;
                        };
                        /** @description Always sent with `print_exceeds_machine`, `print_raster_too_large`. */
                        machine?: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                        /** @description Always sent with `print_exceeds_machine`. */
                        mediaMm?: {
                            heightMm: number;
                            widthMm: number;
                        };
                        /** @description Always sent with `technique_not_offered`. */
                        method?: string;
                        /** @description Always sent with `missing_fulfilment_keys`. */
                        missing?: string[];
                        /** @description Always sent with `print_profile_unavailable`. */
                        outputProfile?: string;
                        /** @description Always sent with `print_exceeds_position`, `print_not_position_size`, `technique_not_offered`, `placement_unfilled`, and may be sent with `print_exceeds_machine`, `print_raster_too_large`. */
                        placement?: string;
                        /** @description Always sent with `duplicate_placement`. */
                        placementId?: string;
                        /** @description Always sent with `print_exceeds_position`, `print_not_position_size`, and may be sent with `field_value_missing`. */
                        position?: string;
                        /** @description Always sent with `print_profile_unavailable`, `print_without_placement`, `print_committed_elsewhere`. */
                        printId?: string;
                        /** @description Always sent with `technique_not_offered`. */
                        printMethods?: string[];
                        /** @description Always sent with `print_exceeds_position`, `print_not_position_size`, `print_exceeds_machine`. */
                        printMm?: {
                            heightMm: number;
                            widthMm: number;
                        };
                        /** @description Always sent with `print_exceeds_machine`, `print_raster_too_large`. */
                        printshop?: string;
                        /** @description Always sent with `unknown_printshop`, `printshop_disconnected`, `printshop_unavailable`, `printshop_differs_from_blank`, `print_exceeds_position`, `print_not_position_size`, `print_exceeds_machine`, `print_raster_too_large`, `technique_not_offered`, `placement_unfilled`, `variant_not_of_blank`, `variant_retired`, `variant_required`, `field_value_missing`, `variant_not_of_design_row`. */
                        reason?: string;
                        /** @description Always sent with `spot_plate_required`. */
                        references?: string[];
                        /** @description Always sent with `variant_not_of_design_row`. */
                        row?: {
                            [key: string]: string;
                        };
                        /** @description Always sent with `print_not_position_size`. */
                        sizeMm?: {
                            heightMm: number;
                            widthMm: number;
                        };
                        /** @description Always sent with `print_raster_too_large`. */
                        sizePx?: {
                            heightPx: number;
                            widthPx: number;
                        };
                        /** @description Always sent with `variant_not_of_blank`, `variant_retired`, `variant_not_of_design_row`. */
                        variant?: string;
                        /** @description Always sent with `variant_required`. */
                        variants?: number;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
            /** @description Refused: lock_timeout */
            503: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
        };
    };
    "orders.get": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The order, its history, and whether it can be submitted again */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        adapter: string;
                        /** @description The blank `blankId` names, as it reads now; `null` as `blankId` is. */
                        blank: {
                            name: string;
                            /** @description Its option axes, in order: how a variant's `options` read, such as Color then Size. */
                            optionAxes: string[];
                            /** @description How many variants it has, retired ones included. */
                            variants: number;
                        } | null;
                        /** @description The blank the order's prints are on; `null` for prints on no blank, or an order placed before it was recorded. */
                        blankId: string | null;
                        canErase: boolean;
                        canRetry: boolean;
                        /** @description The order's latest address change, made with `PATCH /v1/orders/{id}/delivery` after the order was sent; `null` for an order whose address never changed. */
                        delivery: {
                            /** @description When the change was made. */
                            at: number;
                            /** @description What the printshop made of the change: `sending` while it is being told, `accepted`, `refused` (the order keeps the address the printshop has), or `carried` when what the printshop had not been sent yet carries the new address, so nothing extra was sent. */
                            state: string;
                            /** @description The printshop's own answer to a refused change; `null` otherwise. */
                            words: string | null;
                        } | null;
                        /** @description Why `PATCH /v1/orders/{id}/delivery` would refuse a change now, by its error code, or `null` when it would take one. A printshop that is already making the order may still refuse it as `order_past_address_change`: that is known only by asking it. */
                        deliveryChangeRefusal: {
                            /** @enum {string} */
                            code: "address_change_not_accepted";
                        } | {
                            /** @enum {string} */
                            code: "order_past_address_change";
                            status: string;
                            /** @description Its submission has not been answered yet: its printshop has given it no reference. */
                            unanswered: boolean;
                        } | null;
                        /** @description The order's address changes, oldest first, each as its `order.delivery_changed` event recorded it. Never the address. */
                        deliveryChanges: {
                            /** @description The order had no address before: one was added. */
                            added: boolean;
                            /** @description When the change was made, or answered. */
                            at: number;
                            /** @description Who made it: a studio `member`, the `customer` on the design's address capture page, a connected store's integration key (`store_key`), or a `secret_key`. */
                            by: string;
                            /** @description What the printshop made of it at `at`: a change `sending` is listed again once it is answered. */
                            outcome: string;
                            /** @description The printshop's own answer to a refused change. */
                            words: string | null;
                        }[];
                        /** @description The design the lead print was made from. */
                        designId: string;
                        erasable: boolean;
                        externalOrderRef: string | null;
                        externalRef: string | null;
                        /** @description Why Pixonaut failed the order rather than its printshop, as a refusal code: `print_failed` (a print of it could not be made; `lastError` names it), `prints_timed_out` (its prints were not finished within three hours of placing it), or the refusal an order waiting for its prints met when it was handed on, such as `technique_not_offered`. `null` for an order its printshop refused, or one not failed. */
                        failureKind: string | null;
                        fallbackSpots: string[];
                        history: {
                            at: number;
                            /** @description The automation that moved it, by the name it had then; null unless `via` is `automation`. */
                            automation: {
                                id: string;
                                name: string;
                            } | null;
                            reason: string | null;
                            /** @description What released a held order, on `order.released`: the workspace's `upgrade` or the `month_reset`; null otherwise. */
                            releasedBy: string | null;
                            seq: number;
                            status: string;
                            type: string;
                            via: string | null;
                        }[];
                        /** @description Why the order is `held`, while it is; `null` for an order not held. A held order is accepted and not handed to its printshop until the month resets with room for it or the workspace upgrades. */
                        hold: {
                            /** @description The plan's monthly order limit the order met. */
                            limit: number;
                            /** @description When the month resets (ISO 8601, UTC): the latest the order is released, if the new month has room for it. */
                            periodEnd: string;
                            /** @description Why it is held: `monthly_order_limit`, the workspace has placed the orders its plan includes this month. Show a reason you do not know as held without one, never as a failure. */
                            reason: string;
                        } | null;
                        id: string;
                        lastCheckedAt: number | null;
                        lastError: string | null;
                        personalDataErasedAt: number | null;
                        /** @description The order's lead print: the first of `printIds`, and the only one of an order of one print. */
                        printId: string;
                        /** @description Every print the order holds, the lead first: the prints of one item, each in its own placement on its blank. */
                        printIds: string[];
                        /** @description `printIds` with each print's design, placement and file. */
                        prints: ({
                            designId: string;
                            /** @description The revision of the design the print was made from: `GET /v1/designs/{id}/revisions/{revision}/image` draws it. */
                            designRevision: number;
                            /** @description The placement fields the printshop was sent for this print, from its position there; `null` for an order placed before they were recorded. */
                            placementFields: {
                                name: string;
                                /** @description Where the value came from: the variant's (or position's) own, the field's default, or nothing, sent empty. */
                                source: string;
                                value: string;
                            }[] | null;
                            /** @description The placement on its blank the print's design was committed for; `null` for a design with no blank, or one committed before placements were recorded. */
                            placementId: string | null;
                            printId: string;
                            /** @description Where on the item the print goes, by the name the order's printshop knows it by (its Printed as), recorded when the order was placed; `null` for a print on no blank, or an order placed before it was recorded. */
                            printedAs: string | null;
                            /** @description Which of this print's files the printshop was sent; `null` while the order waits for its prints (`awaiting_prints`). */
                            spotOutput: string | null;
                            /** @description Where the print has got to: `created` while it renders, which an order in `awaiting_prints` waits for, then `completed`, or `failed`. */
                            status: string;
                        } | {
                            /** @description A fill print is made from no design. */
                            designId: null;
                            /** @description A fill print: an optional placement of the blank the order left undesigned, printed flat in this colour (`#rrggbb`), its fill colour, at the placement's whole area. */
                            fillColour: string;
                            /** @description The placement fields the printshop was sent for this print, from its position there; `null` for an order placed before they were recorded. */
                            placementFields: {
                                name: string;
                                /** @description Where the value came from: the variant's (or position's) own, the field's default, or nothing, sent empty. */
                                source: string;
                                value: string;
                            }[] | null;
                            /** @description The placement on its blank the print's design was committed for; `null` for a design with no blank, or one committed before placements were recorded. */
                            placementId: string | null;
                            printId: string;
                            /** @description Where on the item the print goes, by the name the order's printshop knows it by (its Printed as), recorded when the order was placed; `null` for a print on no blank, or an order placed before it was recorded. */
                            printedAs: string | null;
                            /** @description Which of this print's files the printshop was sent; `null` while the order waits for its prints (`awaiting_prints`). */
                            spotOutput: string | null;
                            /** @description Where the print has got to: `created` while it renders, which an order in `awaiting_prints` waits for, then `completed`, or `failed`. */
                            status: string;
                        })[];
                        /** @description The printshop as it was when the order was placed: its name and kind (`adapter`). `null` for an order placed before it was recorded. */
                        printshopAsPlaced: {
                            adapter: string;
                            name: string;
                        } | null;
                        printshopConnectionId: string | null;
                        printshopName: string | null;
                        quantity: number;
                        /** @description Who the order is for: its customer. When `shipTo` is set, the order ships there and the customer is who it is finally for. */
                        recipient: {
                            /**
                             * Format: email
                             * @description The recipient's email address, for the carrier's notices.
                             */
                            email?: string;
                            /** @description The recipient's name as a parcel label carries it, a person's or a company's. Up to 200 characters. */
                            name: string;
                            /** @description The recipient's phone number as the customer gave it, with the country code when it has one. */
                            phone?: string;
                        } | null;
                        /** @description Whether mail to the recipient's `email` bounced, so none is sent to it until the address changes; `false` for a recipient with no email, or none. */
                        recipientEmailBounced: boolean;
                        /** @description The order submitted to replace this one, which names it as `replacesOrderId`; `null` for none. */
                        replacedByOrderId: string | null;
                        /** @description The failed order this one was submitted to replace; `null` for an order that replaces none. */
                        replacesOrderId: string | null;
                        /** @description The reroutes this order took part in, by `POST /v1/orders/{id}/retry` with `reroute`, oldest first: the one that sent it here (`target`), then the one that sent it on to another blank (`original`), each naming both blanks, variants and printshops as their orders were placed. Empty for an order not rerouted. */
                        reroutes: {
                            at: number;
                            from: {
                                blankId: string | null;
                                blankName: string | null;
                                /** @description The blank's option axes, in order: how `variantOptions` read. */
                                optionAxes: string[];
                                printshopName: string | null;
                                variantOptions: {
                                    [key: string]: string;
                                } | null;
                                variantRef: string | null;
                            };
                            otherOrderId: string;
                            side: string;
                            to: {
                                blankId: string | null;
                                blankName: string | null;
                                /** @description The blank's option axes, in order: how `variantOptions` read. */
                                optionAxes: string[];
                                printshopName: string | null;
                                variantOptions: {
                                    [key: string]: string;
                                } | null;
                                variantRef: string | null;
                            };
                            via: string | null;
                        }[];
                        retryable: boolean;
                        /** @description The workspace's saved address the order ships to, as it was when the order was placed; `null` for an order that ships to its customer's address. Its printshop is handed this address, and erasing the order's personal data leaves it. */
                        shipTo: {
                            address: {
                                /** @description The city or town. */
                                city: string;
                                /** @description The company of a business address, which the parcel goes to; the recipient is who receives it. */
                                company?: string;
                                /** @description The country as a two-letter ISO 3166-1 code in capitals, such as `SE` or `US`. */
                                country: string;
                                /** @description The first line of the street address: street and number. */
                                line1: string;
                                /** @description The second line of the address: an apartment, floor or c/o. */
                                line2?: string;
                                /** @description The postal code as the country writes it, such as `111 22` or `SW1A 1AA`. Left out where the country has none; a printshop that needs one refuses the order `postal_code_required`. */
                                postalCode?: string;
                                /** @description The state, province or county, where the country uses one. */
                                region?: string;
                            };
                            /** @description What the address is called in the workspace, such as `Warehouse`: unique there, case aside, and the name a parcel sent there is addressed to. Up to 200 characters. */
                            name: string;
                            /** @description The saved address the order ships to, by id. It may have been changed or removed since; `name` and `address` are what the order was placed with. */
                            savedAddressId: string;
                        } | null;
                        /** @description The customer's address. Where the order ships, unless `shipTo` is set. */
                        shippingAddress: {
                            /** @description The city or town. */
                            city: string;
                            /** @description The company of a business address, which the parcel goes to; the recipient is who receives it. */
                            company?: string;
                            /** @description The country as a two-letter ISO 3166-1 code in capitals, such as `SE` or `US`. */
                            country: string;
                            /** @description The first line of the street address: street and number. */
                            line1: string;
                            /** @description The second line of the address: an apartment, floor or c/o. */
                            line2?: string;
                            /** @description The postal code as the country writes it, such as `111 22` or `SW1A 1AA`. Left out where the country has none; a printshop that needs one refuses the order `postal_code_required`. */
                            postalCode?: string;
                            /** @description The state, province or county, where the country uses one. */
                            region?: string;
                        } | null;
                        spotOutput: string | null;
                        status: string;
                        /** @description The statuses this caller may set the order to now with `PATCH /v1/orders/{id}`: for an integration key or a studio member on live, `submitted` and `failed` while its outcome is unknown and nothing otherwise; in a sandbox, every move a secret key may make. Empty for a caller without `orders:update`. */
                        statusMoves: string[];
                        submittedAt: number;
                        tenantId: string;
                        tracking: {
                            /** @description Who carries it, such as `DHL`. */
                            carrier?: string;
                            /** @description The shipment's tracking number. */
                            number: string;
                            /**
                             * Format: uri
                             * @description Where the shipment is followed: an https address.
                             */
                            url?: string;
                        } | null;
                        updatedAt: number;
                        /** @description The variant as it was when the order was placed: its options and the variant fields its printshop was sent. A later edit of the variant does not change it. */
                        variant: {
                            /** @description Each declared field, in the printshop's order, as it was sent. */
                            fields: {
                                name: string;
                                /** @description Where the value came from: the variant's (or position's) own, the field's default, or nothing, sent empty. */
                                source: string;
                                value: string;
                            }[];
                            options: {
                                [key: string]: string;
                            };
                            ref: string;
                        } | null;
                        /** @description The variant the order names; `null` as `blankId` is. */
                        variantRef: string | null;
                        varnishLeftOut: boolean;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: order_not_found, not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "orders.update": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description The printshop's own reference for the order, settling an unknown outcome as `submitted`. */
                    externalOrderRef?: string;
                    /** @description Why: with `failed`, the order's failure note. */
                    reason?: string;
                    /**
                     * @description The order's new status.
                     * @enum {string}
                     */
                    status: "held" | "awaiting_prints" | "submitted" | "queued" | "printed" | "shipped" | "failed" | "outcome_unknown" | "cancelled";
                    /** @description How a shipped order can be followed, with `shipped` only. */
                    tracking?: {
                        /** @description Who carries it, such as `DHL`. */
                        carrier?: string;
                        /** @description The shipment's tracking number. */
                        number: string;
                        /**
                         * Format: uri
                         * @description Where the shipment is followed: an https address.
                         */
                        url?: string;
                    };
                };
            };
        };
        responses: {
            /** @description The order, with its new status */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        adapter: string;
                        /** @description The blank `blankId` names, as it reads now; `null` as `blankId` is. */
                        blank: {
                            name: string;
                            /** @description Its option axes, in order: how a variant's `options` read, such as Color then Size. */
                            optionAxes: string[];
                            /** @description How many variants it has, retired ones included. */
                            variants: number;
                        } | null;
                        /** @description The blank the order's prints are on; `null` for prints on no blank, or an order placed before it was recorded. */
                        blankId: string | null;
                        /** @description The order's latest address change, made with `PATCH /v1/orders/{id}/delivery` after the order was sent; `null` for an order whose address never changed. */
                        delivery: {
                            /** @description When the change was made. */
                            at: number;
                            /** @description What the printshop made of the change: `sending` while it is being told, `accepted`, `refused` (the order keeps the address the printshop has), or `carried` when what the printshop had not been sent yet carries the new address, so nothing extra was sent. */
                            state: string;
                            /** @description The printshop's own answer to a refused change; `null` otherwise. */
                            words: string | null;
                        } | null;
                        /** @description The design the lead print was made from. */
                        designId: string;
                        externalOrderRef: string | null;
                        externalRef: string | null;
                        /** @description Why Pixonaut failed the order rather than its printshop, as a refusal code: `print_failed` (a print of it could not be made; `lastError` names it), `prints_timed_out` (its prints were not finished within three hours of placing it), or the refusal an order waiting for its prints met when it was handed on, such as `technique_not_offered`. `null` for an order its printshop refused, or one not failed. */
                        failureKind: string | null;
                        /** @description Why the order is `held`, while it is; `null` for an order not held. A held order is accepted and not handed to its printshop until the month resets with room for it or the workspace upgrades. */
                        hold: {
                            /** @description The plan's monthly order limit the order met. */
                            limit: number;
                            /** @description When the month resets (ISO 8601, UTC): the latest the order is released, if the new month has room for it. */
                            periodEnd: string;
                            /** @description Why it is held: `monthly_order_limit`, the workspace has placed the orders its plan includes this month. Show a reason you do not know as held without one, never as a failure. */
                            reason: string;
                        } | null;
                        id: string;
                        lastCheckedAt: number | null;
                        lastError: string | null;
                        personalDataErasedAt: number | null;
                        /** @description The order's lead print: the first of `printIds`, and the only one of an order of one print. */
                        printId: string;
                        /** @description Every print the order holds, the lead first: the prints of one item, each in its own placement on its blank. */
                        printIds: string[];
                        /** @description `printIds` with each print's design, placement and file. */
                        prints: ({
                            designId: string;
                            /** @description The revision of the design the print was made from: `GET /v1/designs/{id}/revisions/{revision}/image` draws it. */
                            designRevision: number;
                            /** @description The placement fields the printshop was sent for this print, from its position there; `null` for an order placed before they were recorded. */
                            placementFields: {
                                name: string;
                                /** @description Where the value came from: the variant's (or position's) own, the field's default, or nothing, sent empty. */
                                source: string;
                                value: string;
                            }[] | null;
                            /** @description The placement on its blank the print's design was committed for; `null` for a design with no blank, or one committed before placements were recorded. */
                            placementId: string | null;
                            printId: string;
                            /** @description Where on the item the print goes, by the name the order's printshop knows it by (its Printed as), recorded when the order was placed; `null` for a print on no blank, or an order placed before it was recorded. */
                            printedAs: string | null;
                            /** @description Which of this print's files the printshop was sent; `null` while the order waits for its prints (`awaiting_prints`). */
                            spotOutput: string | null;
                            /** @description Where the print has got to: `created` while it renders, which an order in `awaiting_prints` waits for, then `completed`, or `failed`. */
                            status: string;
                        } | {
                            /** @description A fill print is made from no design. */
                            designId: null;
                            /** @description A fill print: an optional placement of the blank the order left undesigned, printed flat in this colour (`#rrggbb`), its fill colour, at the placement's whole area. */
                            fillColour: string;
                            /** @description The placement fields the printshop was sent for this print, from its position there; `null` for an order placed before they were recorded. */
                            placementFields: {
                                name: string;
                                /** @description Where the value came from: the variant's (or position's) own, the field's default, or nothing, sent empty. */
                                source: string;
                                value: string;
                            }[] | null;
                            /** @description The placement on its blank the print's design was committed for; `null` for a design with no blank, or one committed before placements were recorded. */
                            placementId: string | null;
                            printId: string;
                            /** @description Where on the item the print goes, by the name the order's printshop knows it by (its Printed as), recorded when the order was placed; `null` for a print on no blank, or an order placed before it was recorded. */
                            printedAs: string | null;
                            /** @description Which of this print's files the printshop was sent; `null` while the order waits for its prints (`awaiting_prints`). */
                            spotOutput: string | null;
                            /** @description Where the print has got to: `created` while it renders, which an order in `awaiting_prints` waits for, then `completed`, or `failed`. */
                            status: string;
                        })[];
                        /** @description The printshop as it was when the order was placed: its name and kind (`adapter`). `null` for an order placed before it was recorded. */
                        printshopAsPlaced: {
                            adapter: string;
                            name: string;
                        } | null;
                        printshopConnectionId: string | null;
                        printshopName: string | null;
                        quantity: number;
                        /** @description Who the order is for: its customer. When `shipTo` is set, the order ships there and the customer is who it is finally for. */
                        recipient: {
                            /**
                             * Format: email
                             * @description The recipient's email address, for the carrier's notices.
                             */
                            email?: string;
                            /** @description The recipient's name as a parcel label carries it, a person's or a company's. Up to 200 characters. */
                            name: string;
                            /** @description The recipient's phone number as the customer gave it, with the country code when it has one. */
                            phone?: string;
                        } | null;
                        /** @description The order submitted to replace this one, which names it as `replacesOrderId`; `null` for none. */
                        replacedByOrderId: string | null;
                        /** @description The failed order this one was submitted to replace; `null` for an order that replaces none. */
                        replacesOrderId: string | null;
                        /** @description The workspace's saved address the order ships to, as it was when the order was placed; `null` for an order that ships to its customer's address. Its printshop is handed this address, and erasing the order's personal data leaves it. */
                        shipTo: {
                            address: {
                                /** @description The city or town. */
                                city: string;
                                /** @description The company of a business address, which the parcel goes to; the recipient is who receives it. */
                                company?: string;
                                /** @description The country as a two-letter ISO 3166-1 code in capitals, such as `SE` or `US`. */
                                country: string;
                                /** @description The first line of the street address: street and number. */
                                line1: string;
                                /** @description The second line of the address: an apartment, floor or c/o. */
                                line2?: string;
                                /** @description The postal code as the country writes it, such as `111 22` or `SW1A 1AA`. Left out where the country has none; a printshop that needs one refuses the order `postal_code_required`. */
                                postalCode?: string;
                                /** @description The state, province or county, where the country uses one. */
                                region?: string;
                            };
                            /** @description What the address is called in the workspace, such as `Warehouse`: unique there, case aside, and the name a parcel sent there is addressed to. Up to 200 characters. */
                            name: string;
                            /** @description The saved address the order ships to, by id. It may have been changed or removed since; `name` and `address` are what the order was placed with. */
                            savedAddressId: string;
                        } | null;
                        /** @description The customer's address. Where the order ships, unless `shipTo` is set. */
                        shippingAddress: {
                            /** @description The city or town. */
                            city: string;
                            /** @description The company of a business address, which the parcel goes to; the recipient is who receives it. */
                            company?: string;
                            /** @description The country as a two-letter ISO 3166-1 code in capitals, such as `SE` or `US`. */
                            country: string;
                            /** @description The first line of the street address: street and number. */
                            line1: string;
                            /** @description The second line of the address: an apartment, floor or c/o. */
                            line2?: string;
                            /** @description The postal code as the country writes it, such as `111 22` or `SW1A 1AA`. Left out where the country has none; a printshop that needs one refuses the order `postal_code_required`. */
                            postalCode?: string;
                            /** @description The state, province or county, where the country uses one. */
                            region?: string;
                        } | null;
                        spotOutput: string | null;
                        status: string;
                        submittedAt: number;
                        tenantId: string;
                        tracking: {
                            /** @description Who carries it, such as `DHL`. */
                            carrier?: string;
                            /** @description The shipment's tracking number. */
                            number: string;
                            /**
                             * Format: uri
                             * @description Where the shipment is followed: an https address.
                             */
                            url?: string;
                        } | null;
                        updatedAt: number;
                        /** @description The variant as it was when the order was placed: its options and the variant fields its printshop was sent. A later edit of the variant does not change it. */
                        variant: {
                            /** @description Each declared field, in the printshop's order, as it was sent. */
                            fields: {
                                name: string;
                                /** @description Where the value came from: the variant's (or position's) own, the field's default, or nothing, sent empty. */
                                source: string;
                                value: string;
                            }[];
                            options: {
                                [key: string]: string;
                            };
                            ref: string;
                        } | null;
                        /** @description The variant the order names; `null` as `blankId` is. */
                        variantRef: string | null;
                    };
                };
            };
            /** @description Refused: bad_request */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: order_not_found, not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: order_status_not_allowed, order_reference_taken */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `order_status_not_allowed`. */
                        from?: string;
                        /** @description Always sent with `order_status_not_allowed`. */
                        to?: string;
                    };
                };
            };
            /** @description Refused: order_status_reason_required, payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Sent with `payload_too_large`. */
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `order_status_reason_required`. */
                        from?: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "orders.cancel": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The cancelled order */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        adapter: string;
                        /** @description The blank `blankId` names, as it reads now; `null` as `blankId` is. */
                        blank: {
                            name: string;
                            /** @description Its option axes, in order: how a variant's `options` read, such as Color then Size. */
                            optionAxes: string[];
                            /** @description How many variants it has, retired ones included. */
                            variants: number;
                        } | null;
                        /** @description The blank the order's prints are on; `null` for prints on no blank, or an order placed before it was recorded. */
                        blankId: string | null;
                        /** @description The order's latest address change, made with `PATCH /v1/orders/{id}/delivery` after the order was sent; `null` for an order whose address never changed. */
                        delivery: {
                            /** @description When the change was made. */
                            at: number;
                            /** @description What the printshop made of the change: `sending` while it is being told, `accepted`, `refused` (the order keeps the address the printshop has), or `carried` when what the printshop had not been sent yet carries the new address, so nothing extra was sent. */
                            state: string;
                            /** @description The printshop's own answer to a refused change; `null` otherwise. */
                            words: string | null;
                        } | null;
                        /** @description The design the lead print was made from. */
                        designId: string;
                        externalOrderRef: string | null;
                        externalRef: string | null;
                        /** @description Why Pixonaut failed the order rather than its printshop, as a refusal code: `print_failed` (a print of it could not be made; `lastError` names it), `prints_timed_out` (its prints were not finished within three hours of placing it), or the refusal an order waiting for its prints met when it was handed on, such as `technique_not_offered`. `null` for an order its printshop refused, or one not failed. */
                        failureKind: string | null;
                        /** @description Why the order is `held`, while it is; `null` for an order not held. A held order is accepted and not handed to its printshop until the month resets with room for it or the workspace upgrades. */
                        hold: {
                            /** @description The plan's monthly order limit the order met. */
                            limit: number;
                            /** @description When the month resets (ISO 8601, UTC): the latest the order is released, if the new month has room for it. */
                            periodEnd: string;
                            /** @description Why it is held: `monthly_order_limit`, the workspace has placed the orders its plan includes this month. Show a reason you do not know as held without one, never as a failure. */
                            reason: string;
                        } | null;
                        id: string;
                        lastCheckedAt: number | null;
                        lastError: string | null;
                        personalDataErasedAt: number | null;
                        /** @description The order's lead print: the first of `printIds`, and the only one of an order of one print. */
                        printId: string;
                        /** @description Every print the order holds, the lead first: the prints of one item, each in its own placement on its blank. */
                        printIds: string[];
                        /** @description `printIds` with each print's design, placement and file. */
                        prints: ({
                            designId: string;
                            /** @description The revision of the design the print was made from: `GET /v1/designs/{id}/revisions/{revision}/image` draws it. */
                            designRevision: number;
                            /** @description The placement fields the printshop was sent for this print, from its position there; `null` for an order placed before they were recorded. */
                            placementFields: {
                                name: string;
                                /** @description Where the value came from: the variant's (or position's) own, the field's default, or nothing, sent empty. */
                                source: string;
                                value: string;
                            }[] | null;
                            /** @description The placement on its blank the print's design was committed for; `null` for a design with no blank, or one committed before placements were recorded. */
                            placementId: string | null;
                            printId: string;
                            /** @description Where on the item the print goes, by the name the order's printshop knows it by (its Printed as), recorded when the order was placed; `null` for a print on no blank, or an order placed before it was recorded. */
                            printedAs: string | null;
                            /** @description Which of this print's files the printshop was sent; `null` while the order waits for its prints (`awaiting_prints`). */
                            spotOutput: string | null;
                            /** @description Where the print has got to: `created` while it renders, which an order in `awaiting_prints` waits for, then `completed`, or `failed`. */
                            status: string;
                        } | {
                            /** @description A fill print is made from no design. */
                            designId: null;
                            /** @description A fill print: an optional placement of the blank the order left undesigned, printed flat in this colour (`#rrggbb`), its fill colour, at the placement's whole area. */
                            fillColour: string;
                            /** @description The placement fields the printshop was sent for this print, from its position there; `null` for an order placed before they were recorded. */
                            placementFields: {
                                name: string;
                                /** @description Where the value came from: the variant's (or position's) own, the field's default, or nothing, sent empty. */
                                source: string;
                                value: string;
                            }[] | null;
                            /** @description The placement on its blank the print's design was committed for; `null` for a design with no blank, or one committed before placements were recorded. */
                            placementId: string | null;
                            printId: string;
                            /** @description Where on the item the print goes, by the name the order's printshop knows it by (its Printed as), recorded when the order was placed; `null` for a print on no blank, or an order placed before it was recorded. */
                            printedAs: string | null;
                            /** @description Which of this print's files the printshop was sent; `null` while the order waits for its prints (`awaiting_prints`). */
                            spotOutput: string | null;
                            /** @description Where the print has got to: `created` while it renders, which an order in `awaiting_prints` waits for, then `completed`, or `failed`. */
                            status: string;
                        })[];
                        /** @description The printshop as it was when the order was placed: its name and kind (`adapter`). `null` for an order placed before it was recorded. */
                        printshopAsPlaced: {
                            adapter: string;
                            name: string;
                        } | null;
                        printshopConnectionId: string | null;
                        printshopName: string | null;
                        quantity: number;
                        /** @description Who the order is for: its customer. When `shipTo` is set, the order ships there and the customer is who it is finally for. */
                        recipient: {
                            /**
                             * Format: email
                             * @description The recipient's email address, for the carrier's notices.
                             */
                            email?: string;
                            /** @description The recipient's name as a parcel label carries it, a person's or a company's. Up to 200 characters. */
                            name: string;
                            /** @description The recipient's phone number as the customer gave it, with the country code when it has one. */
                            phone?: string;
                        } | null;
                        /** @description The order submitted to replace this one, which names it as `replacesOrderId`; `null` for none. */
                        replacedByOrderId: string | null;
                        /** @description The failed order this one was submitted to replace; `null` for an order that replaces none. */
                        replacesOrderId: string | null;
                        /** @description The workspace's saved address the order ships to, as it was when the order was placed; `null` for an order that ships to its customer's address. Its printshop is handed this address, and erasing the order's personal data leaves it. */
                        shipTo: {
                            address: {
                                /** @description The city or town. */
                                city: string;
                                /** @description The company of a business address, which the parcel goes to; the recipient is who receives it. */
                                company?: string;
                                /** @description The country as a two-letter ISO 3166-1 code in capitals, such as `SE` or `US`. */
                                country: string;
                                /** @description The first line of the street address: street and number. */
                                line1: string;
                                /** @description The second line of the address: an apartment, floor or c/o. */
                                line2?: string;
                                /** @description The postal code as the country writes it, such as `111 22` or `SW1A 1AA`. Left out where the country has none; a printshop that needs one refuses the order `postal_code_required`. */
                                postalCode?: string;
                                /** @description The state, province or county, where the country uses one. */
                                region?: string;
                            };
                            /** @description What the address is called in the workspace, such as `Warehouse`: unique there, case aside, and the name a parcel sent there is addressed to. Up to 200 characters. */
                            name: string;
                            /** @description The saved address the order ships to, by id. It may have been changed or removed since; `name` and `address` are what the order was placed with. */
                            savedAddressId: string;
                        } | null;
                        /** @description The customer's address. Where the order ships, unless `shipTo` is set. */
                        shippingAddress: {
                            /** @description The city or town. */
                            city: string;
                            /** @description The company of a business address, which the parcel goes to; the recipient is who receives it. */
                            company?: string;
                            /** @description The country as a two-letter ISO 3166-1 code in capitals, such as `SE` or `US`. */
                            country: string;
                            /** @description The first line of the street address: street and number. */
                            line1: string;
                            /** @description The second line of the address: an apartment, floor or c/o. */
                            line2?: string;
                            /** @description The postal code as the country writes it, such as `111 22` or `SW1A 1AA`. Left out where the country has none; a printshop that needs one refuses the order `postal_code_required`. */
                            postalCode?: string;
                            /** @description The state, province or county, where the country uses one. */
                            region?: string;
                        } | null;
                        spotOutput: string | null;
                        status: string;
                        submittedAt: number;
                        tenantId: string;
                        tracking: {
                            /** @description Who carries it, such as `DHL`. */
                            carrier?: string;
                            /** @description The shipment's tracking number. */
                            number: string;
                            /**
                             * Format: uri
                             * @description Where the shipment is followed: an https address.
                             */
                            url?: string;
                        } | null;
                        updatedAt: number;
                        /** @description The variant as it was when the order was placed: its options and the variant fields its printshop was sent. A later edit of the variant does not change it. */
                        variant: {
                            /** @description Each declared field, in the printshop's order, as it was sent. */
                            fields: {
                                name: string;
                                /** @description Where the value came from: the variant's (or position's) own, the field's default, or nothing, sent empty. */
                                source: string;
                                value: string;
                            }[];
                            options: {
                                [key: string]: string;
                            };
                            ref: string;
                        } | null;
                        /** @description The variant the order names; `null` as `blankId` is. */
                        variantRef: string | null;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: order_not_found, not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: order_at_printshop, order_in_flight, order_status_not_allowed */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Always sent with `order_at_printshop`. */
                        cause?: string;
                        /** @description Always sent with `order_in_flight`. */
                        detail?: string;
                        error: string;
                        /** @description Always sent with `order_status_not_allowed`. */
                        from?: string;
                        /** @description Always sent with `order_status_not_allowed`. */
                        to?: string;
                    };
                };
            };
            /** @description Refused: payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
            /** @description Refused: cancel_unavailable */
            503: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `cancel_unavailable`. */
                        reason?: string;
                        /** @description Always sent with `cancel_unavailable`. */
                        retryable?: boolean;
                    };
                };
            };
        };
    };
    "orders.deliveries.list": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The order's steps in the order they are sent, with their status */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description The order's address change steps, oldest first: one for each change its printshop was sent after one of its steps was, as `PATCH /v1/orders/{id}/delivery` sends them. Status only, never what was sent. */
                        addressChanges: {
                            attempts: number;
                            createdAt: number;
                            /** @description When the printshop took it; `null` until it is `accepted`. */
                            deliveredAt: number | null;
                            kind: string;
                            lastAttemptAt: number | null;
                            lastError: string | null;
                            /** @description When it is next tried; `null` while nothing is scheduled. */
                            nextAttemptAt: number | null;
                            status: string;
                        }[];
                        deliveries: {
                            attempts: number;
                            deliveredAt: number | null;
                            kind: string;
                            lastAttemptAt: number | null;
                            /** @description What its last failed send came back with, in words: the shop's answer, or why it could not be sent. */
                            lastError: string | null;
                            /** @description When it is next tried; `null` while nothing is scheduled. */
                            nextAttemptAt: number | null;
                            /** @description Why a `failed` step was never sent, when that is why: its order was cancelled, an earlier step gave up, its personal data was erased, or the order was closed before it went. */
                            notSent: string | null;
                            status: string;
                            stepIndex: number;
                        }[];
                        deliverySteps: boolean;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: order_not_found, not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "orders.delivery.update": {
        parameters: {
            query?: never;
            header?: {
                /** @description Your own key for this request. A repeat with the same key and body within 24 hours is answered with what the first one made, marked `Idempotent-Replayed: true`, and makes nothing; the same key with another body is refused `idempotency_key_reused`, and a repeat while the first is still being answered `idempotency_key_in_use`. A request that is refused makes nothing, so its key may be sent again. */
                "idempotency-key"?: string;
            };
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description Who the order is for. */
                    recipient: {
                        /**
                         * Format: email
                         * @description The recipient's email address, for the carrier's notices.
                         */
                        email?: string;
                        /** @description The recipient's name as a parcel label carries it, a person's or a company's. Up to 200 characters. */
                        name: string;
                        /** @description The recipient's phone number as the customer gave it, with the country code when it has one. */
                        phone?: string;
                    };
                    /** @description Where the order ships. */
                    shippingAddress: {
                        /** @description The city or town. */
                        city: string;
                        /** @description The company of a business address, which the parcel goes to; the recipient is who receives it. */
                        company?: string;
                        /** @description The country as a two-letter ISO 3166-1 code in capitals, such as `SE` or `US`. */
                        country: string;
                        /** @description The first line of the street address: street and number. */
                        line1: string;
                        /** @description The second line of the address: an apartment, floor or c/o. */
                        line2?: string;
                        /** @description The postal code as the country writes it, such as `111 22` or `SW1A 1AA`. Left out where the country has none; a printshop that needs one refuses the order `postal_code_required`. */
                        postalCode?: string;
                        /** @description The state, province or county, where the country uses one. */
                        region?: string;
                    };
                };
            };
        };
        responses: {
            /** @description The order, with its new address */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        adapter: string;
                        /** @description The blank `blankId` names, as it reads now; `null` as `blankId` is. */
                        blank: {
                            name: string;
                            /** @description Its option axes, in order: how a variant's `options` read, such as Color then Size. */
                            optionAxes: string[];
                            /** @description How many variants it has, retired ones included. */
                            variants: number;
                        } | null;
                        /** @description The blank the order's prints are on; `null` for prints on no blank, or an order placed before it was recorded. */
                        blankId: string | null;
                        /** @description The order's latest address change, made with `PATCH /v1/orders/{id}/delivery` after the order was sent; `null` for an order whose address never changed. */
                        delivery: {
                            /** @description When the change was made. */
                            at: number;
                            /** @description What the printshop made of the change: `sending` while it is being told, `accepted`, `refused` (the order keeps the address the printshop has), or `carried` when what the printshop had not been sent yet carries the new address, so nothing extra was sent. */
                            state: string;
                            /** @description The printshop's own answer to a refused change; `null` otherwise. */
                            words: string | null;
                        } | null;
                        /** @description The design the lead print was made from. */
                        designId: string;
                        externalOrderRef: string | null;
                        externalRef: string | null;
                        /** @description Why Pixonaut failed the order rather than its printshop, as a refusal code: `print_failed` (a print of it could not be made; `lastError` names it), `prints_timed_out` (its prints were not finished within three hours of placing it), or the refusal an order waiting for its prints met when it was handed on, such as `technique_not_offered`. `null` for an order its printshop refused, or one not failed. */
                        failureKind: string | null;
                        /** @description Why the order is `held`, while it is; `null` for an order not held. A held order is accepted and not handed to its printshop until the month resets with room for it or the workspace upgrades. */
                        hold: {
                            /** @description The plan's monthly order limit the order met. */
                            limit: number;
                            /** @description When the month resets (ISO 8601, UTC): the latest the order is released, if the new month has room for it. */
                            periodEnd: string;
                            /** @description Why it is held: `monthly_order_limit`, the workspace has placed the orders its plan includes this month. Show a reason you do not know as held without one, never as a failure. */
                            reason: string;
                        } | null;
                        id: string;
                        lastCheckedAt: number | null;
                        lastError: string | null;
                        personalDataErasedAt: number | null;
                        /** @description The order's lead print: the first of `printIds`, and the only one of an order of one print. */
                        printId: string;
                        /** @description Every print the order holds, the lead first: the prints of one item, each in its own placement on its blank. */
                        printIds: string[];
                        /** @description `printIds` with each print's design, placement and file. */
                        prints: ({
                            designId: string;
                            /** @description The revision of the design the print was made from: `GET /v1/designs/{id}/revisions/{revision}/image` draws it. */
                            designRevision: number;
                            /** @description The placement fields the printshop was sent for this print, from its position there; `null` for an order placed before they were recorded. */
                            placementFields: {
                                name: string;
                                /** @description Where the value came from: the variant's (or position's) own, the field's default, or nothing, sent empty. */
                                source: string;
                                value: string;
                            }[] | null;
                            /** @description The placement on its blank the print's design was committed for; `null` for a design with no blank, or one committed before placements were recorded. */
                            placementId: string | null;
                            printId: string;
                            /** @description Where on the item the print goes, by the name the order's printshop knows it by (its Printed as), recorded when the order was placed; `null` for a print on no blank, or an order placed before it was recorded. */
                            printedAs: string | null;
                            /** @description Which of this print's files the printshop was sent; `null` while the order waits for its prints (`awaiting_prints`). */
                            spotOutput: string | null;
                            /** @description Where the print has got to: `created` while it renders, which an order in `awaiting_prints` waits for, then `completed`, or `failed`. */
                            status: string;
                        } | {
                            /** @description A fill print is made from no design. */
                            designId: null;
                            /** @description A fill print: an optional placement of the blank the order left undesigned, printed flat in this colour (`#rrggbb`), its fill colour, at the placement's whole area. */
                            fillColour: string;
                            /** @description The placement fields the printshop was sent for this print, from its position there; `null` for an order placed before they were recorded. */
                            placementFields: {
                                name: string;
                                /** @description Where the value came from: the variant's (or position's) own, the field's default, or nothing, sent empty. */
                                source: string;
                                value: string;
                            }[] | null;
                            /** @description The placement on its blank the print's design was committed for; `null` for a design with no blank, or one committed before placements were recorded. */
                            placementId: string | null;
                            printId: string;
                            /** @description Where on the item the print goes, by the name the order's printshop knows it by (its Printed as), recorded when the order was placed; `null` for a print on no blank, or an order placed before it was recorded. */
                            printedAs: string | null;
                            /** @description Which of this print's files the printshop was sent; `null` while the order waits for its prints (`awaiting_prints`). */
                            spotOutput: string | null;
                            /** @description Where the print has got to: `created` while it renders, which an order in `awaiting_prints` waits for, then `completed`, or `failed`. */
                            status: string;
                        })[];
                        /** @description The printshop as it was when the order was placed: its name and kind (`adapter`). `null` for an order placed before it was recorded. */
                        printshopAsPlaced: {
                            adapter: string;
                            name: string;
                        } | null;
                        printshopConnectionId: string | null;
                        printshopName: string | null;
                        quantity: number;
                        /** @description Who the order is for: its customer. When `shipTo` is set, the order ships there and the customer is who it is finally for. */
                        recipient: {
                            /**
                             * Format: email
                             * @description The recipient's email address, for the carrier's notices.
                             */
                            email?: string;
                            /** @description The recipient's name as a parcel label carries it, a person's or a company's. Up to 200 characters. */
                            name: string;
                            /** @description The recipient's phone number as the customer gave it, with the country code when it has one. */
                            phone?: string;
                        } | null;
                        /** @description The order submitted to replace this one, which names it as `replacesOrderId`; `null` for none. */
                        replacedByOrderId: string | null;
                        /** @description The failed order this one was submitted to replace; `null` for an order that replaces none. */
                        replacesOrderId: string | null;
                        /** @description The workspace's saved address the order ships to, as it was when the order was placed; `null` for an order that ships to its customer's address. Its printshop is handed this address, and erasing the order's personal data leaves it. */
                        shipTo: {
                            address: {
                                /** @description The city or town. */
                                city: string;
                                /** @description The company of a business address, which the parcel goes to; the recipient is who receives it. */
                                company?: string;
                                /** @description The country as a two-letter ISO 3166-1 code in capitals, such as `SE` or `US`. */
                                country: string;
                                /** @description The first line of the street address: street and number. */
                                line1: string;
                                /** @description The second line of the address: an apartment, floor or c/o. */
                                line2?: string;
                                /** @description The postal code as the country writes it, such as `111 22` or `SW1A 1AA`. Left out where the country has none; a printshop that needs one refuses the order `postal_code_required`. */
                                postalCode?: string;
                                /** @description The state, province or county, where the country uses one. */
                                region?: string;
                            };
                            /** @description What the address is called in the workspace, such as `Warehouse`: unique there, case aside, and the name a parcel sent there is addressed to. Up to 200 characters. */
                            name: string;
                            /** @description The saved address the order ships to, by id. It may have been changed or removed since; `name` and `address` are what the order was placed with. */
                            savedAddressId: string;
                        } | null;
                        /** @description The customer's address. Where the order ships, unless `shipTo` is set. */
                        shippingAddress: {
                            /** @description The city or town. */
                            city: string;
                            /** @description The company of a business address, which the parcel goes to; the recipient is who receives it. */
                            company?: string;
                            /** @description The country as a two-letter ISO 3166-1 code in capitals, such as `SE` or `US`. */
                            country: string;
                            /** @description The first line of the street address: street and number. */
                            line1: string;
                            /** @description The second line of the address: an apartment, floor or c/o. */
                            line2?: string;
                            /** @description The postal code as the country writes it, such as `111 22` or `SW1A 1AA`. Left out where the country has none; a printshop that needs one refuses the order `postal_code_required`. */
                            postalCode?: string;
                            /** @description The state, province or county, where the country uses one. */
                            region?: string;
                        } | null;
                        spotOutput: string | null;
                        status: string;
                        submittedAt: number;
                        tenantId: string;
                        tracking: {
                            /** @description Who carries it, such as `DHL`. */
                            carrier?: string;
                            /** @description The shipment's tracking number. */
                            number: string;
                            /**
                             * Format: uri
                             * @description Where the shipment is followed: an https address.
                             */
                            url?: string;
                        } | null;
                        updatedAt: number;
                        /** @description The variant as it was when the order was placed: its options and the variant fields its printshop was sent. A later edit of the variant does not change it. */
                        variant: {
                            /** @description Each declared field, in the printshop's order, as it was sent. */
                            fields: {
                                name: string;
                                /** @description Where the value came from: the variant's (or position's) own, the field's default, or nothing, sent empty. */
                                source: string;
                                value: string;
                            }[];
                            options: {
                                [key: string]: string;
                            };
                            ref: string;
                        } | null;
                        /** @description The variant the order names; `null` as `blankId` is. */
                        variantRef: string | null;
                    };
                };
            };
            /** @description Refused: bad_request */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: order_not_found, not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: order_past_address_change, address_change_not_accepted, idempotency_key_in_use */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `address_change_not_accepted`. */
                        printshop?: string | null;
                        /** @description Always sent with `order_past_address_change`. */
                        status?: string;
                        /** @description Always sent with `order_past_address_change`. */
                        words?: string | null;
                    };
                };
            };
            /** @description Refused: postal_code_required, idempotency_key_reused, invalid_idempotency_key, payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Sent with `payload_too_large`. */
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
            /** @description Refused: address_change_unavailable */
            503: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `address_change_unavailable`. */
                        reason?: string;
                        /** @description Always sent with `address_change_unavailable`. */
                        retryable?: boolean;
                    };
                };
            };
        };
    };
    "orders.erasePersonalData": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The order, without its personal data */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        adapter: string;
                        /** @description The blank `blankId` names, as it reads now; `null` as `blankId` is. */
                        blank: {
                            name: string;
                            /** @description Its option axes, in order: how a variant's `options` read, such as Color then Size. */
                            optionAxes: string[];
                            /** @description How many variants it has, retired ones included. */
                            variants: number;
                        } | null;
                        /** @description The blank the order's prints are on; `null` for prints on no blank, or an order placed before it was recorded. */
                        blankId: string | null;
                        /** @description The order's latest address change, made with `PATCH /v1/orders/{id}/delivery` after the order was sent; `null` for an order whose address never changed. */
                        delivery: {
                            /** @description When the change was made. */
                            at: number;
                            /** @description What the printshop made of the change: `sending` while it is being told, `accepted`, `refused` (the order keeps the address the printshop has), or `carried` when what the printshop had not been sent yet carries the new address, so nothing extra was sent. */
                            state: string;
                            /** @description The printshop's own answer to a refused change; `null` otherwise. */
                            words: string | null;
                        } | null;
                        /** @description The design the lead print was made from. */
                        designId: string;
                        externalOrderRef: string | null;
                        externalRef: string | null;
                        /** @description Why Pixonaut failed the order rather than its printshop, as a refusal code: `print_failed` (a print of it could not be made; `lastError` names it), `prints_timed_out` (its prints were not finished within three hours of placing it), or the refusal an order waiting for its prints met when it was handed on, such as `technique_not_offered`. `null` for an order its printshop refused, or one not failed. */
                        failureKind: string | null;
                        /** @description Why the order is `held`, while it is; `null` for an order not held. A held order is accepted and not handed to its printshop until the month resets with room for it or the workspace upgrades. */
                        hold: {
                            /** @description The plan's monthly order limit the order met. */
                            limit: number;
                            /** @description When the month resets (ISO 8601, UTC): the latest the order is released, if the new month has room for it. */
                            periodEnd: string;
                            /** @description Why it is held: `monthly_order_limit`, the workspace has placed the orders its plan includes this month. Show a reason you do not know as held without one, never as a failure. */
                            reason: string;
                        } | null;
                        id: string;
                        lastCheckedAt: number | null;
                        lastError: string | null;
                        personalDataErasedAt: number | null;
                        /** @description The order's lead print: the first of `printIds`, and the only one of an order of one print. */
                        printId: string;
                        /** @description Every print the order holds, the lead first: the prints of one item, each in its own placement on its blank. */
                        printIds: string[];
                        /** @description `printIds` with each print's design, placement and file. */
                        prints: ({
                            designId: string;
                            /** @description The revision of the design the print was made from: `GET /v1/designs/{id}/revisions/{revision}/image` draws it. */
                            designRevision: number;
                            /** @description The placement fields the printshop was sent for this print, from its position there; `null` for an order placed before they were recorded. */
                            placementFields: {
                                name: string;
                                /** @description Where the value came from: the variant's (or position's) own, the field's default, or nothing, sent empty. */
                                source: string;
                                value: string;
                            }[] | null;
                            /** @description The placement on its blank the print's design was committed for; `null` for a design with no blank, or one committed before placements were recorded. */
                            placementId: string | null;
                            printId: string;
                            /** @description Where on the item the print goes, by the name the order's printshop knows it by (its Printed as), recorded when the order was placed; `null` for a print on no blank, or an order placed before it was recorded. */
                            printedAs: string | null;
                            /** @description Which of this print's files the printshop was sent; `null` while the order waits for its prints (`awaiting_prints`). */
                            spotOutput: string | null;
                            /** @description Where the print has got to: `created` while it renders, which an order in `awaiting_prints` waits for, then `completed`, or `failed`. */
                            status: string;
                        } | {
                            /** @description A fill print is made from no design. */
                            designId: null;
                            /** @description A fill print: an optional placement of the blank the order left undesigned, printed flat in this colour (`#rrggbb`), its fill colour, at the placement's whole area. */
                            fillColour: string;
                            /** @description The placement fields the printshop was sent for this print, from its position there; `null` for an order placed before they were recorded. */
                            placementFields: {
                                name: string;
                                /** @description Where the value came from: the variant's (or position's) own, the field's default, or nothing, sent empty. */
                                source: string;
                                value: string;
                            }[] | null;
                            /** @description The placement on its blank the print's design was committed for; `null` for a design with no blank, or one committed before placements were recorded. */
                            placementId: string | null;
                            printId: string;
                            /** @description Where on the item the print goes, by the name the order's printshop knows it by (its Printed as), recorded when the order was placed; `null` for a print on no blank, or an order placed before it was recorded. */
                            printedAs: string | null;
                            /** @description Which of this print's files the printshop was sent; `null` while the order waits for its prints (`awaiting_prints`). */
                            spotOutput: string | null;
                            /** @description Where the print has got to: `created` while it renders, which an order in `awaiting_prints` waits for, then `completed`, or `failed`. */
                            status: string;
                        })[];
                        /** @description The printshop as it was when the order was placed: its name and kind (`adapter`). `null` for an order placed before it was recorded. */
                        printshopAsPlaced: {
                            adapter: string;
                            name: string;
                        } | null;
                        printshopConnectionId: string | null;
                        printshopName: string | null;
                        quantity: number;
                        /** @description Who the order is for: its customer. When `shipTo` is set, the order ships there and the customer is who it is finally for. */
                        recipient: {
                            /**
                             * Format: email
                             * @description The recipient's email address, for the carrier's notices.
                             */
                            email?: string;
                            /** @description The recipient's name as a parcel label carries it, a person's or a company's. Up to 200 characters. */
                            name: string;
                            /** @description The recipient's phone number as the customer gave it, with the country code when it has one. */
                            phone?: string;
                        } | null;
                        /** @description The order submitted to replace this one, which names it as `replacesOrderId`; `null` for none. */
                        replacedByOrderId: string | null;
                        /** @description The failed order this one was submitted to replace; `null` for an order that replaces none. */
                        replacesOrderId: string | null;
                        /** @description The workspace's saved address the order ships to, as it was when the order was placed; `null` for an order that ships to its customer's address. Its printshop is handed this address, and erasing the order's personal data leaves it. */
                        shipTo: {
                            address: {
                                /** @description The city or town. */
                                city: string;
                                /** @description The company of a business address, which the parcel goes to; the recipient is who receives it. */
                                company?: string;
                                /** @description The country as a two-letter ISO 3166-1 code in capitals, such as `SE` or `US`. */
                                country: string;
                                /** @description The first line of the street address: street and number. */
                                line1: string;
                                /** @description The second line of the address: an apartment, floor or c/o. */
                                line2?: string;
                                /** @description The postal code as the country writes it, such as `111 22` or `SW1A 1AA`. Left out where the country has none; a printshop that needs one refuses the order `postal_code_required`. */
                                postalCode?: string;
                                /** @description The state, province or county, where the country uses one. */
                                region?: string;
                            };
                            /** @description What the address is called in the workspace, such as `Warehouse`: unique there, case aside, and the name a parcel sent there is addressed to. Up to 200 characters. */
                            name: string;
                            /** @description The saved address the order ships to, by id. It may have been changed or removed since; `name` and `address` are what the order was placed with. */
                            savedAddressId: string;
                        } | null;
                        /** @description The customer's address. Where the order ships, unless `shipTo` is set. */
                        shippingAddress: {
                            /** @description The city or town. */
                            city: string;
                            /** @description The company of a business address, which the parcel goes to; the recipient is who receives it. */
                            company?: string;
                            /** @description The country as a two-letter ISO 3166-1 code in capitals, such as `SE` or `US`. */
                            country: string;
                            /** @description The first line of the street address: street and number. */
                            line1: string;
                            /** @description The second line of the address: an apartment, floor or c/o. */
                            line2?: string;
                            /** @description The postal code as the country writes it, such as `111 22` or `SW1A 1AA`. Left out where the country has none; a printshop that needs one refuses the order `postal_code_required`. */
                            postalCode?: string;
                            /** @description The state, province or county, where the country uses one. */
                            region?: string;
                        } | null;
                        spotOutput: string | null;
                        status: string;
                        submittedAt: number;
                        tenantId: string;
                        tracking: {
                            /** @description Who carries it, such as `DHL`. */
                            carrier?: string;
                            /** @description The shipment's tracking number. */
                            number: string;
                            /**
                             * Format: uri
                             * @description Where the shipment is followed: an https address.
                             */
                            url?: string;
                        } | null;
                        updatedAt: number;
                        /** @description The variant as it was when the order was placed: its options and the variant fields its printshop was sent. A later edit of the variant does not change it. */
                        variant: {
                            /** @description Each declared field, in the printshop's order, as it was sent. */
                            fields: {
                                name: string;
                                /** @description Where the value came from: the variant's (or position's) own, the field's default, or nothing, sent empty. */
                                source: string;
                                value: string;
                            }[];
                            options: {
                                [key: string]: string;
                            };
                            ref: string;
                        } | null;
                        /** @description The variant the order names; `null` as `blankId` is. */
                        variantRef: string | null;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: order_not_found, not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: order_in_flight */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Always sent with `order_in_flight`. */
                        detail?: string;
                        error: string;
                    };
                };
            };
            /** @description Refused: payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
            /** @description Refused: lock_timeout */
            503: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
        };
    };
    "orders.job.get": {
        parameters: {
            query?: {
                machineProfile?: string;
            };
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The order's job */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description The carriers the order's printshop has shipped with, from this page or a secret key's move here. */
                        carriers: {
                            /** @description The carrier its latest shipment named, typed or listed; null before its first. */
                            last: string | null;
                            /** @description Carriers the printshop typed itself rather than picked from the page's list, the most recently used first. */
                            saved: string[];
                            /** @description How many carriers the printshop typed itself in all. */
                            savedCount: number;
                        };
                        id: string;
                        machineProfileAskedId: string | null;
                        machineProfileId: string | null;
                        machineProfiles: {
                            id: string;
                            name: string;
                        }[];
                        prints: {
                            placementId: string | null;
                            printId: string;
                            /** @description Where on the item the print goes, by the name the order's printshop knows it by (its Printed as), recorded when the order was placed; `null` for a print on no blank, or an order placed before it was recorded. */
                            printedAs: string | null;
                            /** @description This print's ticket for its own machine: `machineProfile` applies to the order's `ticket` alone. */
                            ticket: {
                                artifact: {
                                    colorSpace: string;
                                    cut?: {
                                        bleedMm: number;
                                        cropMarks: boolean;
                                        cutLine: boolean;
                                        cutName: string | null;
                                        markOffsetMm: number;
                                        mirrored: boolean;
                                        part: string;
                                        profile: string;
                                        registrationMarks: string;
                                        underbase: {
                                            chokeMm: number;
                                            coverage: string;
                                            spotName: string;
                                        } | null;
                                        varnish: {
                                            coverage: string;
                                            spotName: string;
                                        } | null;
                                    };
                                    effectiveDpi: number;
                                    file: string;
                                    format: string;
                                    iccProfile: string;
                                    includesBleed: boolean;
                                    spotColors: string[];
                                    spotOutput: string;
                                    trimMarks: boolean;
                                };
                                artwork: {
                                    name?: string;
                                    templateId: string;
                                } | {
                                    fillColour: string;
                                    name: string;
                                };
                                externalRef: string | null;
                                fulfilmentPayload?: unknown;
                                manifest: {
                                    docHash: string;
                                    fontSetHash: string;
                                    iccProfile: string;
                                    renderedAt: string;
                                    rendererVersion: string;
                                    templateVersion?: string;
                                };
                                printArea: {
                                    anchor?: {
                                        /** @description How the print aligns to the reference: `top-left`, `top-center`, `top-right`, `center-left`, `center`, `center-right`, `bottom-left`, `bottom-center` or `bottom-right`. Anything else is read as `center`. */
                                        align: string;
                                        /** @description How far the print is moved from the reference, in millimetres. y grows downward. */
                                        offsetMm: {
                                            /** @description Horizontal offset in millimetres; positive moves right. */
                                            x: number;
                                            /** @description Vertical offset in millimetres; positive moves down. */
                                            y: number;
                                        };
                                        /** @description The physical reference the print is positioned against on the product. */
                                        reference: string;
                                    };
                                    bleedMm?: number;
                                    cutShape: {
                                        d: string;
                                        type: string;
                                    };
                                    heightMm: number;
                                    /** @description The linked group the design is one placement of: one design drives every placement it names. Absent for a design on one placement alone. */
                                    linked?: {
                                        /** @description Whether this placement's print is mirrored left to right. */
                                        mirrored: boolean;
                                        /** @description The group's placements, by id. */
                                        placements: string[];
                                        /** @description The width of the group's widest print area, in mm: what a repeat across the group is sized against, so it prints at one physical scale on every placement. */
                                        referenceWidthMm: number;
                                    };
                                    printMethod?: string;
                                    printedAs?: string;
                                    /** @description The repeat the print was drawn as: the design's mode, size and seed, and the printed size of the tile laid across the print. Absent for a print that does not repeat. */
                                    repeat?: {
                                        /** @description How the tiles are laid: `grid` lines them up, `brick` moves every other row along by half a tile, `halfDrop` moves every other column down by half a tile, and `scatter` strews them at random places, turns and sizes, arranged by `seed`. */
                                        mode: string;
                                        /** @description Which arrangement a `scatter` draws: another seed is another arrangement of the same tile. Read by `scatter` only. */
                                        seed: number;
                                        /** @description The tile's width in percent of the print area's width, above 0 and at most 100; the tile keeps the template's shape. A tile that would print under 10 mm on a side is drawn at 10 mm. */
                                        size: number;
                                        /** @description The tile's printed height in millimetres. */
                                        unitHeightMm: number;
                                        /** @description The tile's printed width in millimetres. */
                                        unitWidthMm: number;
                                    };
                                    safeAreaMm?: number;
                                    shape?: {
                                        /** @description True when the print shop cuts the product to this shape: the outline and the cut-outs go into the print file as its cut line. Omitted, the product already has the shape. */
                                        cutByPrintShop?: boolean;
                                        /** @description The shape as SVG path data in fractions of the print area, 0 to 1 across and down (curves, no arcs): its first subpath the outline, every further one a cut-out, filled even-odd, each subpath closed. */
                                        dFrac: string;
                                    };
                                    widthMm: number;
                                };
                                product: {
                                    sku: string;
                                    tenantId: string;
                                };
                                quantity: number;
                                recipient?: {
                                    /**
                                     * Format: email
                                     * @description The recipient's email address, for the carrier's notices.
                                     */
                                    email?: string;
                                    /** @description The recipient's name as a parcel label carries it, a person's or a company's. Up to 200 characters. */
                                    name: string;
                                    /** @description The recipient's phone number as the customer gave it, with the country code when it has one. */
                                    phone?: string;
                                };
                                shippingAddress?: {
                                    /** @description The city or town. */
                                    city: string;
                                    /** @description The company of a business address, which the parcel goes to; the recipient is who receives it. */
                                    company?: string;
                                    /** @description The country as a two-letter ISO 3166-1 code in capitals, such as `SE` or `US`. */
                                    country: string;
                                    /** @description The first line of the street address: street and number. */
                                    line1: string;
                                    /** @description The second line of the address: an apartment, floor or c/o. */
                                    line2?: string;
                                    /** @description The postal code as the country writes it, such as `111 22` or `SW1A 1AA`. Left out where the country has none; a printshop that needs one refuses the order `postal_code_required`. */
                                    postalCode?: string;
                                    /** @description The state, province or county, where the country uses one. */
                                    region?: string;
                                };
                            } | null;
                        }[];
                        status: string;
                        submittedAt: number;
                        ticket: {
                            artifact: {
                                colorSpace: string;
                                cut?: {
                                    bleedMm: number;
                                    cropMarks: boolean;
                                    cutLine: boolean;
                                    cutName: string | null;
                                    markOffsetMm: number;
                                    mirrored: boolean;
                                    part: string;
                                    profile: string;
                                    registrationMarks: string;
                                    underbase: {
                                        chokeMm: number;
                                        coverage: string;
                                        spotName: string;
                                    } | null;
                                    varnish: {
                                        coverage: string;
                                        spotName: string;
                                    } | null;
                                };
                                effectiveDpi: number;
                                file: string;
                                format: string;
                                iccProfile: string;
                                includesBleed: boolean;
                                spotColors: string[];
                                spotOutput: string;
                                trimMarks: boolean;
                            };
                            artwork: {
                                name?: string;
                                templateId: string;
                            } | {
                                fillColour: string;
                                name: string;
                            };
                            externalRef: string | null;
                            fulfilmentPayload?: unknown;
                            manifest: {
                                docHash: string;
                                fontSetHash: string;
                                iccProfile: string;
                                renderedAt: string;
                                rendererVersion: string;
                                templateVersion?: string;
                            };
                            printArea: {
                                anchor?: {
                                    /** @description How the print aligns to the reference: `top-left`, `top-center`, `top-right`, `center-left`, `center`, `center-right`, `bottom-left`, `bottom-center` or `bottom-right`. Anything else is read as `center`. */
                                    align: string;
                                    /** @description How far the print is moved from the reference, in millimetres. y grows downward. */
                                    offsetMm: {
                                        /** @description Horizontal offset in millimetres; positive moves right. */
                                        x: number;
                                        /** @description Vertical offset in millimetres; positive moves down. */
                                        y: number;
                                    };
                                    /** @description The physical reference the print is positioned against on the product. */
                                    reference: string;
                                };
                                bleedMm?: number;
                                cutShape: {
                                    d: string;
                                    type: string;
                                };
                                heightMm: number;
                                /** @description The linked group the design is one placement of: one design drives every placement it names. Absent for a design on one placement alone. */
                                linked?: {
                                    /** @description Whether this placement's print is mirrored left to right. */
                                    mirrored: boolean;
                                    /** @description The group's placements, by id. */
                                    placements: string[];
                                    /** @description The width of the group's widest print area, in mm: what a repeat across the group is sized against, so it prints at one physical scale on every placement. */
                                    referenceWidthMm: number;
                                };
                                printMethod?: string;
                                printedAs?: string;
                                /** @description The repeat the print was drawn as: the design's mode, size and seed, and the printed size of the tile laid across the print. Absent for a print that does not repeat. */
                                repeat?: {
                                    /** @description How the tiles are laid: `grid` lines them up, `brick` moves every other row along by half a tile, `halfDrop` moves every other column down by half a tile, and `scatter` strews them at random places, turns and sizes, arranged by `seed`. */
                                    mode: string;
                                    /** @description Which arrangement a `scatter` draws: another seed is another arrangement of the same tile. Read by `scatter` only. */
                                    seed: number;
                                    /** @description The tile's width in percent of the print area's width, above 0 and at most 100; the tile keeps the template's shape. A tile that would print under 10 mm on a side is drawn at 10 mm. */
                                    size: number;
                                    /** @description The tile's printed height in millimetres. */
                                    unitHeightMm: number;
                                    /** @description The tile's printed width in millimetres. */
                                    unitWidthMm: number;
                                };
                                safeAreaMm?: number;
                                shape?: {
                                    /** @description True when the print shop cuts the product to this shape: the outline and the cut-outs go into the print file as its cut line. Omitted, the product already has the shape. */
                                    cutByPrintShop?: boolean;
                                    /** @description The shape as SVG path data in fractions of the print area, 0 to 1 across and down (curves, no arcs): its first subpath the outline, every further one a cut-out, filled even-odd, each subpath closed. */
                                    dFrac: string;
                                };
                                widthMm: number;
                            };
                            product: {
                                sku: string;
                                tenantId: string;
                            };
                            quantity: number;
                            recipient?: {
                                /**
                                 * Format: email
                                 * @description The recipient's email address, for the carrier's notices.
                                 */
                                email?: string;
                                /** @description The recipient's name as a parcel label carries it, a person's or a company's. Up to 200 characters. */
                                name: string;
                                /** @description The recipient's phone number as the customer gave it, with the country code when it has one. */
                                phone?: string;
                            };
                            shippingAddress?: {
                                /** @description The city or town. */
                                city: string;
                                /** @description The company of a business address, which the parcel goes to; the recipient is who receives it. */
                                company?: string;
                                /** @description The country as a two-letter ISO 3166-1 code in capitals, such as `SE` or `US`. */
                                country: string;
                                /** @description The first line of the street address: street and number. */
                                line1: string;
                                /** @description The second line of the address: an apartment, floor or c/o. */
                                line2?: string;
                                /** @description The postal code as the country writes it, such as `111 22` or `SW1A 1AA`. Left out where the country has none; a printshop that needs one refuses the order `postal_code_required`. */
                                postalCode?: string;
                                /** @description The state, province or county, where the country uses one. */
                                region?: string;
                            };
                        } | null;
                        tracking: {
                            /** @description Who carries it, such as `DHL`. */
                            carrier?: string;
                            /** @description The shipment's tracking number. */
                            number: string;
                            /**
                             * Format: uri
                             * @description Where the shipment is followed: an https address.
                             */
                            url?: string;
                        } | null;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, secret_key_required, feature_disabled */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: order_not_found, machine_profile_not_found, not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: spot_plate_required */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Always sent with `spot_plate_required`. */
                        cause?: string;
                        error: string;
                        /** @description Always sent with `spot_plate_required`. */
                        references?: string[];
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "orders.job.update": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description Why: with `failed`, the order's failure note. */
                    reason?: string;
                    /**
                     * @description The order's new status.
                     * @enum {string}
                     */
                    status: "held" | "awaiting_prints" | "submitted" | "queued" | "printed" | "shipped" | "failed" | "outcome_unknown" | "cancelled";
                    /** @description How a shipped order can be followed, with `shipped` only. */
                    tracking?: {
                        /** @description Who carries it, such as `DHL`. */
                        carrier?: string;
                        /** @description The shipment's tracking number. */
                        number: string;
                        /**
                         * Format: uri
                         * @description Where the shipment is followed: an https address.
                         */
                        url?: string;
                    };
                };
            };
        };
        responses: {
            /** @description The order's job, as it now stands */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description The carriers the order's printshop has shipped with, from this page or a secret key's move here. */
                        carriers: {
                            /** @description The carrier its latest shipment named, typed or listed; null before its first. */
                            last: string | null;
                            /** @description Carriers the printshop typed itself rather than picked from the page's list, the most recently used first. */
                            saved: string[];
                            /** @description How many carriers the printshop typed itself in all. */
                            savedCount: number;
                        };
                        id: string;
                        machineProfileAskedId: string | null;
                        machineProfileId: string | null;
                        machineProfiles: {
                            id: string;
                            name: string;
                        }[];
                        prints: {
                            placementId: string | null;
                            printId: string;
                            /** @description Where on the item the print goes, by the name the order's printshop knows it by (its Printed as), recorded when the order was placed; `null` for a print on no blank, or an order placed before it was recorded. */
                            printedAs: string | null;
                            /** @description This print's ticket for its own machine: `machineProfile` applies to the order's `ticket` alone. */
                            ticket: {
                                artifact: {
                                    colorSpace: string;
                                    cut?: {
                                        bleedMm: number;
                                        cropMarks: boolean;
                                        cutLine: boolean;
                                        cutName: string | null;
                                        markOffsetMm: number;
                                        mirrored: boolean;
                                        part: string;
                                        profile: string;
                                        registrationMarks: string;
                                        underbase: {
                                            chokeMm: number;
                                            coverage: string;
                                            spotName: string;
                                        } | null;
                                        varnish: {
                                            coverage: string;
                                            spotName: string;
                                        } | null;
                                    };
                                    effectiveDpi: number;
                                    file: string;
                                    format: string;
                                    iccProfile: string;
                                    includesBleed: boolean;
                                    spotColors: string[];
                                    spotOutput: string;
                                    trimMarks: boolean;
                                };
                                artwork: {
                                    name?: string;
                                    templateId: string;
                                } | {
                                    fillColour: string;
                                    name: string;
                                };
                                externalRef: string | null;
                                fulfilmentPayload?: unknown;
                                manifest: {
                                    docHash: string;
                                    fontSetHash: string;
                                    iccProfile: string;
                                    renderedAt: string;
                                    rendererVersion: string;
                                    templateVersion?: string;
                                };
                                printArea: {
                                    anchor?: {
                                        /** @description How the print aligns to the reference: `top-left`, `top-center`, `top-right`, `center-left`, `center`, `center-right`, `bottom-left`, `bottom-center` or `bottom-right`. Anything else is read as `center`. */
                                        align: string;
                                        /** @description How far the print is moved from the reference, in millimetres. y grows downward. */
                                        offsetMm: {
                                            /** @description Horizontal offset in millimetres; positive moves right. */
                                            x: number;
                                            /** @description Vertical offset in millimetres; positive moves down. */
                                            y: number;
                                        };
                                        /** @description The physical reference the print is positioned against on the product. */
                                        reference: string;
                                    };
                                    bleedMm?: number;
                                    cutShape: {
                                        d: string;
                                        type: string;
                                    };
                                    heightMm: number;
                                    /** @description The linked group the design is one placement of: one design drives every placement it names. Absent for a design on one placement alone. */
                                    linked?: {
                                        /** @description Whether this placement's print is mirrored left to right. */
                                        mirrored: boolean;
                                        /** @description The group's placements, by id. */
                                        placements: string[];
                                        /** @description The width of the group's widest print area, in mm: what a repeat across the group is sized against, so it prints at one physical scale on every placement. */
                                        referenceWidthMm: number;
                                    };
                                    printMethod?: string;
                                    printedAs?: string;
                                    /** @description The repeat the print was drawn as: the design's mode, size and seed, and the printed size of the tile laid across the print. Absent for a print that does not repeat. */
                                    repeat?: {
                                        /** @description How the tiles are laid: `grid` lines them up, `brick` moves every other row along by half a tile, `halfDrop` moves every other column down by half a tile, and `scatter` strews them at random places, turns and sizes, arranged by `seed`. */
                                        mode: string;
                                        /** @description Which arrangement a `scatter` draws: another seed is another arrangement of the same tile. Read by `scatter` only. */
                                        seed: number;
                                        /** @description The tile's width in percent of the print area's width, above 0 and at most 100; the tile keeps the template's shape. A tile that would print under 10 mm on a side is drawn at 10 mm. */
                                        size: number;
                                        /** @description The tile's printed height in millimetres. */
                                        unitHeightMm: number;
                                        /** @description The tile's printed width in millimetres. */
                                        unitWidthMm: number;
                                    };
                                    safeAreaMm?: number;
                                    shape?: {
                                        /** @description True when the print shop cuts the product to this shape: the outline and the cut-outs go into the print file as its cut line. Omitted, the product already has the shape. */
                                        cutByPrintShop?: boolean;
                                        /** @description The shape as SVG path data in fractions of the print area, 0 to 1 across and down (curves, no arcs): its first subpath the outline, every further one a cut-out, filled even-odd, each subpath closed. */
                                        dFrac: string;
                                    };
                                    widthMm: number;
                                };
                                product: {
                                    sku: string;
                                    tenantId: string;
                                };
                                quantity: number;
                                recipient?: {
                                    /**
                                     * Format: email
                                     * @description The recipient's email address, for the carrier's notices.
                                     */
                                    email?: string;
                                    /** @description The recipient's name as a parcel label carries it, a person's or a company's. Up to 200 characters. */
                                    name: string;
                                    /** @description The recipient's phone number as the customer gave it, with the country code when it has one. */
                                    phone?: string;
                                };
                                shippingAddress?: {
                                    /** @description The city or town. */
                                    city: string;
                                    /** @description The company of a business address, which the parcel goes to; the recipient is who receives it. */
                                    company?: string;
                                    /** @description The country as a two-letter ISO 3166-1 code in capitals, such as `SE` or `US`. */
                                    country: string;
                                    /** @description The first line of the street address: street and number. */
                                    line1: string;
                                    /** @description The second line of the address: an apartment, floor or c/o. */
                                    line2?: string;
                                    /** @description The postal code as the country writes it, such as `111 22` or `SW1A 1AA`. Left out where the country has none; a printshop that needs one refuses the order `postal_code_required`. */
                                    postalCode?: string;
                                    /** @description The state, province or county, where the country uses one. */
                                    region?: string;
                                };
                            } | null;
                        }[];
                        status: string;
                        submittedAt: number;
                        ticket: {
                            artifact: {
                                colorSpace: string;
                                cut?: {
                                    bleedMm: number;
                                    cropMarks: boolean;
                                    cutLine: boolean;
                                    cutName: string | null;
                                    markOffsetMm: number;
                                    mirrored: boolean;
                                    part: string;
                                    profile: string;
                                    registrationMarks: string;
                                    underbase: {
                                        chokeMm: number;
                                        coverage: string;
                                        spotName: string;
                                    } | null;
                                    varnish: {
                                        coverage: string;
                                        spotName: string;
                                    } | null;
                                };
                                effectiveDpi: number;
                                file: string;
                                format: string;
                                iccProfile: string;
                                includesBleed: boolean;
                                spotColors: string[];
                                spotOutput: string;
                                trimMarks: boolean;
                            };
                            artwork: {
                                name?: string;
                                templateId: string;
                            } | {
                                fillColour: string;
                                name: string;
                            };
                            externalRef: string | null;
                            fulfilmentPayload?: unknown;
                            manifest: {
                                docHash: string;
                                fontSetHash: string;
                                iccProfile: string;
                                renderedAt: string;
                                rendererVersion: string;
                                templateVersion?: string;
                            };
                            printArea: {
                                anchor?: {
                                    /** @description How the print aligns to the reference: `top-left`, `top-center`, `top-right`, `center-left`, `center`, `center-right`, `bottom-left`, `bottom-center` or `bottom-right`. Anything else is read as `center`. */
                                    align: string;
                                    /** @description How far the print is moved from the reference, in millimetres. y grows downward. */
                                    offsetMm: {
                                        /** @description Horizontal offset in millimetres; positive moves right. */
                                        x: number;
                                        /** @description Vertical offset in millimetres; positive moves down. */
                                        y: number;
                                    };
                                    /** @description The physical reference the print is positioned against on the product. */
                                    reference: string;
                                };
                                bleedMm?: number;
                                cutShape: {
                                    d: string;
                                    type: string;
                                };
                                heightMm: number;
                                /** @description The linked group the design is one placement of: one design drives every placement it names. Absent for a design on one placement alone. */
                                linked?: {
                                    /** @description Whether this placement's print is mirrored left to right. */
                                    mirrored: boolean;
                                    /** @description The group's placements, by id. */
                                    placements: string[];
                                    /** @description The width of the group's widest print area, in mm: what a repeat across the group is sized against, so it prints at one physical scale on every placement. */
                                    referenceWidthMm: number;
                                };
                                printMethod?: string;
                                printedAs?: string;
                                /** @description The repeat the print was drawn as: the design's mode, size and seed, and the printed size of the tile laid across the print. Absent for a print that does not repeat. */
                                repeat?: {
                                    /** @description How the tiles are laid: `grid` lines them up, `brick` moves every other row along by half a tile, `halfDrop` moves every other column down by half a tile, and `scatter` strews them at random places, turns and sizes, arranged by `seed`. */
                                    mode: string;
                                    /** @description Which arrangement a `scatter` draws: another seed is another arrangement of the same tile. Read by `scatter` only. */
                                    seed: number;
                                    /** @description The tile's width in percent of the print area's width, above 0 and at most 100; the tile keeps the template's shape. A tile that would print under 10 mm on a side is drawn at 10 mm. */
                                    size: number;
                                    /** @description The tile's printed height in millimetres. */
                                    unitHeightMm: number;
                                    /** @description The tile's printed width in millimetres. */
                                    unitWidthMm: number;
                                };
                                safeAreaMm?: number;
                                shape?: {
                                    /** @description True when the print shop cuts the product to this shape: the outline and the cut-outs go into the print file as its cut line. Omitted, the product already has the shape. */
                                    cutByPrintShop?: boolean;
                                    /** @description The shape as SVG path data in fractions of the print area, 0 to 1 across and down (curves, no arcs): its first subpath the outline, every further one a cut-out, filled even-odd, each subpath closed. */
                                    dFrac: string;
                                };
                                widthMm: number;
                            };
                            product: {
                                sku: string;
                                tenantId: string;
                            };
                            quantity: number;
                            recipient?: {
                                /**
                                 * Format: email
                                 * @description The recipient's email address, for the carrier's notices.
                                 */
                                email?: string;
                                /** @description The recipient's name as a parcel label carries it, a person's or a company's. Up to 200 characters. */
                                name: string;
                                /** @description The recipient's phone number as the customer gave it, with the country code when it has one. */
                                phone?: string;
                            };
                            shippingAddress?: {
                                /** @description The city or town. */
                                city: string;
                                /** @description The company of a business address, which the parcel goes to; the recipient is who receives it. */
                                company?: string;
                                /** @description The country as a two-letter ISO 3166-1 code in capitals, such as `SE` or `US`. */
                                country: string;
                                /** @description The first line of the street address: street and number. */
                                line1: string;
                                /** @description The second line of the address: an apartment, floor or c/o. */
                                line2?: string;
                                /** @description The postal code as the country writes it, such as `111 22` or `SW1A 1AA`. Left out where the country has none; a printshop that needs one refuses the order `postal_code_required`. */
                                postalCode?: string;
                                /** @description The state, province or county, where the country uses one. */
                                region?: string;
                            };
                        } | null;
                        tracking: {
                            /** @description Who carries it, such as `DHL`. */
                            carrier?: string;
                            /** @description The shipment's tracking number. */
                            number: string;
                            /**
                             * Format: uri
                             * @description Where the shipment is followed: an https address.
                             */
                            url?: string;
                        } | null;
                    };
                };
            };
            /** @description Refused: bad_request */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: order_not_found, not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: order_status_not_allowed, order_reference_taken */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `order_status_not_allowed`. */
                        from?: string;
                        /** @description Always sent with `order_status_not_allowed`. */
                        to?: string;
                    };
                };
            };
            /** @description Refused: order_status_reason_required, payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Sent with `payload_too_large`. */
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `order_status_reason_required`. */
                        from?: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "orders.job.files.bundle": {
        parameters: {
            query?: {
                machineProfile?: string;
                settings?: string;
                /** @description Which of the order's prints, one of its `printIds`. Required when the order holds several; left out, the order's only print. */
                printId?: string;
                /** @description Sets of files to add beside the print's own, as a JSON array: each `{"machineProfile": "<id>"}`, a machine profile of the tenant's printshops, or `{"settings": {…}}`, output settings for this download only. At most 10. */
                add?: string;
            };
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The print's files and job ticket, zipped */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/zip": string;
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: order_not_found, print_not_found, machine_profile_not_found, part_not_offered, separation_not_found, file_not_found, not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: ink_mask_missing, print_profile_unavailable, print_raster_too_large, print_id_required, invalid_query */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `print_id_required`. */
                        printIds?: string[];
                        /** @description Always sent with `print_raster_too_large`. */
                        reason?: string;
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "orders.job.files.get": {
        parameters: {
            query?: {
                machineProfile?: string;
                settings?: string;
                /** @description Which of the order's prints, one of its `printIds`. Required when the order holds several; left out, the order's only print. */
                printId?: string;
                part?: "combined" | "print" | "cut";
                file?: "process" | "separated";
            };
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The print file */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/pdf": string;
                    "image/png": string;
                    "image/tiff": string;
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: order_not_found, print_not_found, machine_profile_not_found, part_not_offered, separation_not_found, file_not_found, not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: spot_plate_required, ink_mask_missing, print_profile_unavailable, print_raster_too_large, print_id_required, invalid_query */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Always sent with `spot_plate_required`. */
                        cause?: string;
                        error: string;
                        /** @description Always sent with `print_id_required`. */
                        printIds?: string[];
                        /** @description Always sent with `print_raster_too_large`. */
                        reason?: string;
                        /** @description Always sent with `spot_plate_required`. */
                        references?: string[];
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "orders.job.files.list": {
        parameters: {
            query?: {
                machineProfile?: string;
                settings?: string;
                /** @description Which of the order's prints, one of its `printIds`. Required when the order holds several; left out, the order's only print. */
                printId?: string;
            };
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The order's files */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        machineProfileAskedId: string | null;
                        machineProfileId: string | null;
                        machineProfiles: {
                            id: string;
                            name: string;
                        }[];
                        separationMissing: boolean;
                        settings: {
                            /** @description The bleed the file is trimmed to, in mm, or null for the bleed it was rendered with. */
                            bleedTrimMm: number | null;
                            /** @description Whether crop marks are drawn for a rectangular cut. */
                            cropMarks: boolean;
                            /** @description The name the cut path is drawn under, or null for a machine that cuts nothing. */
                            cutName: string | null;
                            /** @description How much further out than by default the marks sit, in mm. */
                            markOffsetMm: number;
                            /** @description Whether the print is mirrored. */
                            mirror: boolean;
                            /** @description The marks the machine reads off the printed sheet. */
                            registrationMarks: string;
                            /** @description A UV machine's white laid under the colour, or null for none. */
                            underbase: {
                                /** @description How far in from the inked edge the white stops, in mm; 0 leaves it to the RIP. */
                                chokeMm: number;
                                /** @description Where the white lies. */
                                coverage: string;
                                /** @description The spot name the printshop's RIP reads for this channel. */
                                spotName: string;
                            } | null;
                            /** @description A UV machine's varnish laid over the colour, or null for none. */
                            varnish: {
                                /** @description Where the varnish lies when the design marks no layer for spot varnish. */
                                coverage: string;
                                /** @description The spot name the printshop's RIP reads for this channel. */
                                spotName: string;
                            } | null;
                        } | null;
                        variants: {
                            file: string;
                            handedOut: boolean;
                            isDefault: boolean;
                            part: string;
                            url: string;
                        }[];
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: order_not_found, print_not_found, machine_profile_not_found, not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: spot_plate_required, print_id_required, invalid_query */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Always sent with `spot_plate_required`. */
                        cause?: string;
                        error: string;
                        /** @description Always sent with `print_id_required`. */
                        printIds?: string[];
                        /** @description Always sent with `spot_plate_required`. */
                        references?: string[];
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "orders.progress.get": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The order's progress */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        id: string;
                        status: string;
                        /** @description Each status the order reached, oldest first, and when. A failed order that was sent again shows the steps of the order that took its place. */
                        steps: {
                            at: number;
                            status: string;
                        }[];
                        submittedAt: number;
                        tracking: {
                            /** @description Who carries it, such as `DHL`. */
                            carrier?: string;
                            /** @description The shipment's tracking number. */
                            number: string;
                            /**
                             * Format: uri
                             * @description Where the shipment is followed: an https address.
                             */
                            url?: string;
                        } | null;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, secret_key_required, feature_disabled */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: order_not_found, not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
            /** @description Refused: lock_timeout */
            503: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
        };
    };
    "orders.rerouteTargets": {
        parameters: {
            query?: {
                /** @description The page to read, from 1; the first when left out. */
                page?: number;
                /** @description Only the blanks whose name, or whose printshop's name, holds this text, case aside. */
                q?: string;
            };
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description A page of blanks */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description How many of the `total` blanks the order fits. */
                        fitting: number;
                        page: number;
                        pageSize: number;
                        targets: {
                            blankId: string;
                            /** @description For a blank the order fits, each print and the placements it may go to; empty otherwise. */
                            candidates: {
                                placements: {
                                    id: string;
                                    /** @description The largest print it takes. */
                                    largestMm: {
                                        heightMm: number;
                                        widthMm: number;
                                    };
                                    name: string;
                                    /** @description It has the print's own placement's name, so the print goes there and nowhere else. */
                                    sameName: boolean;
                                }[];
                                printId: string;
                            }[];
                            fits: boolean;
                            /** @description For a blank the order does not fit, why; empty otherwise. */
                            misfits: ({
                                /** @enum {string} */
                                kind: "print_exceeds_placement";
                                largestMm: {
                                    heightMm: number;
                                    widthMm: number;
                                };
                                placement: string;
                                printId: string;
                                printMm: {
                                    heightMm: number;
                                    widthMm: number;
                                };
                            } | {
                                /** @description The placement's area: it is printed across all of it, so a print must be that size. */
                                areaMm: {
                                    heightMm: number;
                                    widthMm: number;
                                };
                                /** @enum {string} */
                                kind: "print_short_of_area";
                                placement: string;
                                printId: string;
                                printMm: {
                                    heightMm: number;
                                    widthMm: number;
                                };
                            } | {
                                /** @enum {string} */
                                kind: "technique_differs";
                                placement: string;
                                placementMethod: string;
                                printId: string;
                                printMethod: string;
                            } | {
                                /** @enum {string} */
                                kind: "technique_unknown";
                                placement: string;
                                placementMethod: string | null;
                                printId: string;
                                printMethod: string | null;
                            } | {
                                /** @enum {string} */
                                kind: "no_placement_fits";
                                /** @description The print's own placement's name; `null` for none. */
                                placement: string | null;
                                printId: string;
                            } | {
                                /** @enum {string} */
                                kind: "too_few_placements";
                            })[];
                            name: string;
                            /** @description The names of the blank's placements, in its order. */
                            placements: string[];
                            /** @description The printshop the blank is made at, which the order would go to. */
                            printshop: {
                                id: string;
                                name: string;
                            } | null;
                            /** @description How many variants the blank has, retired ones included. */
                            variants: number;
                        }[];
                        total: number;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: order_not_found, not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: order_not_retryable, order_at_printshop, order_superseded, print_ticket_stale */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Always sent with `print_ticket_stale`. */
                        detail?: string;
                        error: string;
                        /** @description Always sent with `order_superseded`. */
                        newerOrderId?: string;
                        /** @description Always sent with `order_not_retryable`. */
                        status?: string;
                    };
                };
            };
            /** @description Refused: invalid_query */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "orders.retry": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": {
                    /** @description Sends the order to another blank rather than back to its own: the same prints, copies, reference and address, at that blank's printshop. The prints are not made again, so each must fit the placement it goes to: its trim size within the placement's largest print, never turned, and made by the placement's print method. `GET /v1/orders/{id}/reroute-targets` lists the blanks it fits. */
                    reroute?: {
                        /** @description The blank to send the order to: any other blank of the workspace. The order goes to its printshop. */
                        blankId: string;
                        /** @description Where each print of the order goes on the blank, one placement each. A print goes to the placement of its own placement's name when the blank has one, matched without regard to case. */
                        placements: {
                            /** @description The placement on the blank the print goes to. */
                            placementId: string;
                            printId: string;
                        }[];
                        /** @description The variant of that blank the order is for, by ref. May be left out for a blank with one variant. */
                        variant?: string;
                    };
                } | null;
            };
        };
        responses: {
            /** @description The new order */
            201: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        adapter: string;
                        /** @description The blank `blankId` names, as it reads now; `null` as `blankId` is. */
                        blank: {
                            name: string;
                            /** @description Its option axes, in order: how a variant's `options` read, such as Color then Size. */
                            optionAxes: string[];
                            /** @description How many variants it has, retired ones included. */
                            variants: number;
                        } | null;
                        /** @description The blank the order's prints are on; `null` for prints on no blank, or an order placed before it was recorded. */
                        blankId: string | null;
                        /** @description The order's latest address change, made with `PATCH /v1/orders/{id}/delivery` after the order was sent; `null` for an order whose address never changed. */
                        delivery: {
                            /** @description When the change was made. */
                            at: number;
                            /** @description What the printshop made of the change: `sending` while it is being told, `accepted`, `refused` (the order keeps the address the printshop has), or `carried` when what the printshop had not been sent yet carries the new address, so nothing extra was sent. */
                            state: string;
                            /** @description The printshop's own answer to a refused change; `null` otherwise. */
                            words: string | null;
                        } | null;
                        /** @description The design the lead print was made from. */
                        designId: string;
                        externalOrderRef: string | null;
                        externalRef: string | null;
                        /** @description Why Pixonaut failed the order rather than its printshop, as a refusal code: `print_failed` (a print of it could not be made; `lastError` names it), `prints_timed_out` (its prints were not finished within three hours of placing it), or the refusal an order waiting for its prints met when it was handed on, such as `technique_not_offered`. `null` for an order its printshop refused, or one not failed. */
                        failureKind: string | null;
                        /** @description Why the order is `held`, while it is; `null` for an order not held. A held order is accepted and not handed to its printshop until the month resets with room for it or the workspace upgrades. */
                        hold: {
                            /** @description The plan's monthly order limit the order met. */
                            limit: number;
                            /** @description When the month resets (ISO 8601, UTC): the latest the order is released, if the new month has room for it. */
                            periodEnd: string;
                            /** @description Why it is held: `monthly_order_limit`, the workspace has placed the orders its plan includes this month. Show a reason you do not know as held without one, never as a failure. */
                            reason: string;
                        } | null;
                        id: string;
                        lastCheckedAt: number | null;
                        lastError: string | null;
                        personalDataErasedAt: number | null;
                        /** @description The order's lead print: the first of `printIds`, and the only one of an order of one print. */
                        printId: string;
                        /** @description Every print the order holds, the lead first: the prints of one item, each in its own placement on its blank. */
                        printIds: string[];
                        /** @description `printIds` with each print's design, placement and file. */
                        prints: ({
                            designId: string;
                            /** @description The revision of the design the print was made from: `GET /v1/designs/{id}/revisions/{revision}/image` draws it. */
                            designRevision: number;
                            /** @description The placement fields the printshop was sent for this print, from its position there; `null` for an order placed before they were recorded. */
                            placementFields: {
                                name: string;
                                /** @description Where the value came from: the variant's (or position's) own, the field's default, or nothing, sent empty. */
                                source: string;
                                value: string;
                            }[] | null;
                            /** @description The placement on its blank the print's design was committed for; `null` for a design with no blank, or one committed before placements were recorded. */
                            placementId: string | null;
                            printId: string;
                            /** @description Where on the item the print goes, by the name the order's printshop knows it by (its Printed as), recorded when the order was placed; `null` for a print on no blank, or an order placed before it was recorded. */
                            printedAs: string | null;
                            /** @description Which of this print's files the printshop was sent; `null` while the order waits for its prints (`awaiting_prints`). */
                            spotOutput: string | null;
                            /** @description Where the print has got to: `created` while it renders, which an order in `awaiting_prints` waits for, then `completed`, or `failed`. */
                            status: string;
                        } | {
                            /** @description A fill print is made from no design. */
                            designId: null;
                            /** @description A fill print: an optional placement of the blank the order left undesigned, printed flat in this colour (`#rrggbb`), its fill colour, at the placement's whole area. */
                            fillColour: string;
                            /** @description The placement fields the printshop was sent for this print, from its position there; `null` for an order placed before they were recorded. */
                            placementFields: {
                                name: string;
                                /** @description Where the value came from: the variant's (or position's) own, the field's default, or nothing, sent empty. */
                                source: string;
                                value: string;
                            }[] | null;
                            /** @description The placement on its blank the print's design was committed for; `null` for a design with no blank, or one committed before placements were recorded. */
                            placementId: string | null;
                            printId: string;
                            /** @description Where on the item the print goes, by the name the order's printshop knows it by (its Printed as), recorded when the order was placed; `null` for a print on no blank, or an order placed before it was recorded. */
                            printedAs: string | null;
                            /** @description Which of this print's files the printshop was sent; `null` while the order waits for its prints (`awaiting_prints`). */
                            spotOutput: string | null;
                            /** @description Where the print has got to: `created` while it renders, which an order in `awaiting_prints` waits for, then `completed`, or `failed`. */
                            status: string;
                        })[];
                        /** @description The printshop as it was when the order was placed: its name and kind (`adapter`). `null` for an order placed before it was recorded. */
                        printshopAsPlaced: {
                            adapter: string;
                            name: string;
                        } | null;
                        printshopConnectionId: string | null;
                        printshopName: string | null;
                        quantity: number;
                        /** @description Who the order is for: its customer. When `shipTo` is set, the order ships there and the customer is who it is finally for. */
                        recipient: {
                            /**
                             * Format: email
                             * @description The recipient's email address, for the carrier's notices.
                             */
                            email?: string;
                            /** @description The recipient's name as a parcel label carries it, a person's or a company's. Up to 200 characters. */
                            name: string;
                            /** @description The recipient's phone number as the customer gave it, with the country code when it has one. */
                            phone?: string;
                        } | null;
                        /** @description The order submitted to replace this one, which names it as `replacesOrderId`; `null` for none. */
                        replacedByOrderId: string | null;
                        /** @description The failed order this one was submitted to replace; `null` for an order that replaces none. */
                        replacesOrderId: string | null;
                        /** @description The workspace's saved address the order ships to, as it was when the order was placed; `null` for an order that ships to its customer's address. Its printshop is handed this address, and erasing the order's personal data leaves it. */
                        shipTo: {
                            address: {
                                /** @description The city or town. */
                                city: string;
                                /** @description The company of a business address, which the parcel goes to; the recipient is who receives it. */
                                company?: string;
                                /** @description The country as a two-letter ISO 3166-1 code in capitals, such as `SE` or `US`. */
                                country: string;
                                /** @description The first line of the street address: street and number. */
                                line1: string;
                                /** @description The second line of the address: an apartment, floor or c/o. */
                                line2?: string;
                                /** @description The postal code as the country writes it, such as `111 22` or `SW1A 1AA`. Left out where the country has none; a printshop that needs one refuses the order `postal_code_required`. */
                                postalCode?: string;
                                /** @description The state, province or county, where the country uses one. */
                                region?: string;
                            };
                            /** @description What the address is called in the workspace, such as `Warehouse`: unique there, case aside, and the name a parcel sent there is addressed to. Up to 200 characters. */
                            name: string;
                            /** @description The saved address the order ships to, by id. It may have been changed or removed since; `name` and `address` are what the order was placed with. */
                            savedAddressId: string;
                        } | null;
                        /** @description The customer's address. Where the order ships, unless `shipTo` is set. */
                        shippingAddress: {
                            /** @description The city or town. */
                            city: string;
                            /** @description The company of a business address, which the parcel goes to; the recipient is who receives it. */
                            company?: string;
                            /** @description The country as a two-letter ISO 3166-1 code in capitals, such as `SE` or `US`. */
                            country: string;
                            /** @description The first line of the street address: street and number. */
                            line1: string;
                            /** @description The second line of the address: an apartment, floor or c/o. */
                            line2?: string;
                            /** @description The postal code as the country writes it, such as `111 22` or `SW1A 1AA`. Left out where the country has none; a printshop that needs one refuses the order `postal_code_required`. */
                            postalCode?: string;
                            /** @description The state, province or county, where the country uses one. */
                            region?: string;
                        } | null;
                        spotOutput: string | null;
                        status: string;
                        submittedAt: number;
                        tenantId: string;
                        tracking: {
                            /** @description Who carries it, such as `DHL`. */
                            carrier?: string;
                            /** @description The shipment's tracking number. */
                            number: string;
                            /**
                             * Format: uri
                             * @description Where the shipment is followed: an https address.
                             */
                            url?: string;
                        } | null;
                        updatedAt: number;
                        /** @description The variant as it was when the order was placed: its options and the variant fields its printshop was sent. A later edit of the variant does not change it. */
                        variant: {
                            /** @description Each declared field, in the printshop's order, as it was sent. */
                            fields: {
                                name: string;
                                /** @description Where the value came from: the variant's (or position's) own, the field's default, or nothing, sent empty. */
                                source: string;
                                value: string;
                            }[];
                            options: {
                                [key: string]: string;
                            };
                            ref: string;
                        } | null;
                        /** @description The variant the order names; `null` as `blankId` is. */
                        variantRef: string | null;
                    };
                };
            };
            /** @description Refused: bad_request */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: plan_limit_reached, origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                        /** @description The limit the tenant is at: `templates`, `connectedStores`, `apiKeys`, `shareLinks`, `customDomains`, `printsMadePerMonth` (prints made without an order this month), `members`, `orders` (this month's orders, which getting a print's files without an order counts as), or a sandbox's own caps: `sandboxPrintsPerDay`, `sandboxPrintsPerMonth`, `sandboxOrdersPerMonth`. A sandbox shares every other limit with its live workspace. Always sent with `plan_limit_reached`. */
                        limit?: string;
                        /** @description How many the plan allows. Always sent with `plan_limit_reached`. */
                        max?: number;
                        /** @description The plan whose limit it is. Always sent with `plan_limit_reached`. */
                        plan?: string;
                    };
                };
            };
            /** @description Refused: print_not_found, order_not_found, not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: print_not_completed, print_needs_printshop, print_ticket_stale, print_superseded, print_files_deleted, design_erased, stale_update, design_already_ordered, printshop_paused, order_not_retryable, order_at_printshop, order_superseded */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Always sent with `stale_update`. */
                        current?: number;
                        /** @description Always sent with `design_already_ordered`. */
                        designId?: string;
                        /** @description Always sent with `print_ticket_stale`. */
                        detail?: string;
                        error: string;
                        /** @description Always sent with `order_superseded`. */
                        newerOrderId?: string;
                        /** @description Always sent with `design_already_ordered`. */
                        orderId?: string;
                        /** @description Always sent with `printshop_paused`. */
                        reason?: string;
                        /** @description Always sent with `print_not_completed`, `order_not_retryable`. With `order_not_retryable`: one of `held`, `awaiting_prints`, `submitted`, `queued`, `printed`, `shipped`, `failed`, `outcome_unknown`, `cancelled`. */
                        status?: string;
                    };
                };
            };
            /** @description Refused: unknown_printshop, printshop_disconnected, printshop_unavailable, printshop_differs_from_blank, missing_fulfilment_keys, postal_code_required, saved_address_not_found, spot_plate_required, print_profile_unavailable, print_exceeds_position, print_not_position_size, print_exceeds_machine, print_raster_too_large, technique_not_offered, placement_unfilled, variant_not_of_blank, variant_retired, variant_required, field_value_missing, variant_not_of_design_row, print_without_placement, mixed_blanks, duplicate_placement, print_committed_elsewhere, printshop_cannot_combine, prints_disagree, reroute_blank_not_found, reroute_same_blank, print_not_of_order, print_not_mapped, print_mapped_twice, placement_not_of_blank, placement_taken, placement_name_differs, print_exceeds_placement, print_short_of_area, technique_differs, technique_unknown, payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Always sent with `print_short_of_area`. */
                        areaMm?: {
                            heightMm: number;
                            widthMm: number;
                        };
                        /** @description Sent with `payload_too_large`. */
                        bytes?: number;
                        /** @description Always sent with `spot_plate_required`. */
                        cause?: string;
                        /** @description Always sent with `variant_not_of_design_row`. */
                        designId?: string;
                        /** @description Always sent with `print_profile_unavailable`. */
                        detail?: string;
                        error: string;
                        /** @description Always sent with `field_value_missing`. */
                        field?: string;
                        /** @description Always sent with `field_value_missing`. */
                        fieldKind?: string;
                        /** @description Always sent with `prints_disagree`. */
                        key?: string;
                        /** @description Always sent with `print_exceeds_position`, `print_exceeds_placement`. */
                        largestMm?: {
                            heightMm: number;
                            widthMm: number;
                        };
                        /** @description Always sent with `print_exceeds_machine`, `print_raster_too_large`. */
                        machine?: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                        /** @description Always sent with `print_exceeds_machine`. */
                        mediaMm?: {
                            heightMm: number;
                            widthMm: number;
                        };
                        /** @description Always sent with `technique_not_offered`. */
                        method?: string;
                        /** @description Always sent with `missing_fulfilment_keys`. */
                        missing?: string[];
                        /** @description Always sent with `placement_name_differs`. */
                        named?: string;
                        /** @description Always sent with `print_profile_unavailable`. */
                        outputProfile?: string;
                        /** @description Always sent with `print_exceeds_position`, `print_not_position_size`, `technique_not_offered`, `placement_unfilled`, `placement_taken`, `placement_name_differs`, `print_exceeds_placement`, `print_short_of_area`, `technique_differs`, `technique_unknown`, and may be sent with `print_exceeds_machine`, `print_raster_too_large`. */
                        placement?: string;
                        /** @description Always sent with `duplicate_placement`, `placement_not_of_blank`. */
                        placementId?: string;
                        /** @description Always sent with `technique_differs`, `technique_unknown`. */
                        placementMethod?: string | null;
                        /** @description Always sent with `print_exceeds_position`, `print_not_position_size`, and may be sent with `field_value_missing`. */
                        position?: string;
                        /** @description Always sent with `print_profile_unavailable`, `print_without_placement`, `print_committed_elsewhere`, `print_not_of_order`, `print_not_mapped`, `print_mapped_twice`, `placement_name_differs`, `print_exceeds_placement`, `print_short_of_area`, `technique_differs`, `technique_unknown`. */
                        printId?: string;
                        /** @description Always sent with `placement_taken`. */
                        printIds?: string[];
                        /** @description Always sent with `technique_differs`, `technique_unknown`. */
                        printMethod?: string | null;
                        /** @description Always sent with `technique_not_offered`. */
                        printMethods?: string[];
                        /** @description Always sent with `print_exceeds_position`, `print_not_position_size`, `print_exceeds_machine`, `print_exceeds_placement`, `print_short_of_area`. */
                        printMm?: {
                            heightMm: number;
                            widthMm: number;
                        };
                        /** @description Always sent with `print_exceeds_machine`, `print_raster_too_large`. */
                        printshop?: string;
                        /** @description Always sent with `unknown_printshop`, `printshop_disconnected`, `printshop_unavailable`, `printshop_differs_from_blank`, `print_exceeds_position`, `print_not_position_size`, `print_exceeds_machine`, `print_raster_too_large`, `technique_not_offered`, `placement_unfilled`, `variant_not_of_blank`, `variant_retired`, `variant_required`, `field_value_missing`, `variant_not_of_design_row`, `reroute_blank_not_found`, `reroute_same_blank`, `print_not_of_order`, `print_not_mapped`, `print_mapped_twice`, `placement_not_of_blank`, `placement_taken`, `placement_name_differs`, `print_exceeds_placement`, `print_short_of_area`, `technique_differs`, `technique_unknown`. */
                        reason?: string;
                        /** @description Always sent with `spot_plate_required`. */
                        references?: string[];
                        /** @description Always sent with `variant_not_of_design_row`. */
                        row?: {
                            [key: string]: string;
                        };
                        /** @description Always sent with `print_not_position_size`. */
                        sizeMm?: {
                            heightMm: number;
                            widthMm: number;
                        };
                        /** @description Always sent with `print_raster_too_large`. */
                        sizePx?: {
                            heightPx: number;
                            widthPx: number;
                        };
                        /** @description Always sent with `variant_not_of_blank`, `variant_retired`, `variant_not_of_design_row`. */
                        variant?: string;
                        /** @description Always sent with `variant_required`. */
                        variants?: number;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
            /** @description Refused: lock_timeout */
            503: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
        };
    };
    "pixelApplications.create": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    cardId: string;
                    conversationId: string;
                    /**
                     * @description Don't ask again, on a card that spends credits: turns "Confirm before spending credits" off, so later spends are applied without a card. Refused for any other card, which always asks.
                     * @enum {boolean}
                     */
                    dontAskAgain?: true;
                };
            };
        };
        responses: {
            /** @description The card was applied */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        conversation: {
                            cards: {
                                [key: string]: {
                                    change?: {
                                        added: {
                                            label: string;
                                            renamedTo?: string;
                                            text?: string;
                                            type: string;
                                        }[];
                                        changed: {
                                            label: string;
                                            renamedTo?: string;
                                            text?: string;
                                            type: string;
                                        }[];
                                        removed: {
                                            label: string;
                                            renamedTo?: string;
                                            text?: string;
                                            type: string;
                                        }[];
                                        restyled: boolean;
                                    };
                                    current?: {
                                        name?: string;
                                    };
                                    estimate?: {
                                        availableCredits: number;
                                        credits: number;
                                    };
                                    input?: unknown;
                                    pictures?: {
                                        assetId: string;
                                        heightPx: number;
                                        letteringUnreliable: boolean;
                                        widthPx: number;
                                    }[];
                                    refusedWith?: string;
                                    runId?: string;
                                    savedRevisions?: {
                                        [key: string]: number;
                                    };
                                    showcases?: {
                                        baseId: string;
                                        before: {
                                            id: string;
                                            name: string;
                                            values: {
                                                [key: string]: {
                                                    [key: string]: unknown;
                                                };
                                            };
                                        }[];
                                        name: string;
                                    }[];
                                    status: string;
                                    tool: string;
                                    upscaleId?: string;
                                };
                            };
                            contentKeys: {
                                [key: string]: string;
                            };
                            id: string;
                            messages: ({
                                content: string | ({
                                    text: string;
                                    /** @enum {string} */
                                    type: "text";
                                } | {
                                    assetId: string;
                                    /** @enum {string} */
                                    type: "attachment";
                                } | {
                                    /** @enum {string} */
                                    type: "upload";
                                    uploadId: string;
                                } | {
                                    content: string | ({
                                        text: string;
                                        /** @enum {string} */
                                        type: "text";
                                    } | {
                                        of: {
                                            id: string;
                                            /** @enum {string} */
                                            kind: "template";
                                        } | {
                                            id: string;
                                            /** @enum {string} */
                                            kind: "design";
                                            revision: number;
                                        } | {
                                            id: string;
                                            /** @enum {string} */
                                            kind: "asset";
                                        } | {
                                            id: string;
                                            /** @enum {string} */
                                            kind: "upload";
                                        } | {
                                            id: string;
                                            /** @enum {string} */
                                            kind: "trial";
                                            values: {
                                                [key: string]: {
                                                    [key: string]: unknown;
                                                };
                                            };
                                        } | {
                                            blankId: string;
                                            id: string;
                                            /** @enum {string} */
                                            kind: "template_mockup";
                                            mockupId?: string;
                                            placementId: string;
                                            viewId?: string;
                                        } | {
                                            id: string;
                                            /** @enum {string} */
                                            kind: "design_mockup";
                                            mockupId?: string;
                                            placementId?: string;
                                            viewId?: string;
                                        };
                                        /** @enum {string} */
                                        type: "picture";
                                    })[];
                                    is_error?: boolean;
                                    tool_use_id: string;
                                    /** @enum {string} */
                                    type: "tool_result";
                                })[];
                                /** @enum {string} */
                                role: "user";
                            } | {
                                content: ({
                                    text: string;
                                    /** @enum {string} */
                                    type: "text";
                                } | {
                                    id: string;
                                    input?: unknown;
                                    name: string;
                                    /** @enum {string} */
                                    type: "tool_use";
                                } | {
                                    id: string;
                                    input?: unknown;
                                    name: string;
                                    /** @enum {string} */
                                    type: "server_tool_use";
                                } | {
                                    content: {
                                        tool_references: {
                                            tool_name: string;
                                            type: string;
                                        }[];
                                        /** @enum {string} */
                                        type: "tool_search_tool_search_result";
                                    } | {
                                        error_code: string;
                                        /** @enum {string} */
                                        type: "tool_search_tool_result_error";
                                    };
                                    tool_use_id: string;
                                    /** @enum {string} */
                                    type: "tool_search_tool_result";
                                })[];
                                /** @enum {string} */
                                role: "assistant";
                            })[];
                            unavailable: string[];
                            unseen: string[];
                            uploads: {
                                [key: string]: {
                                    kind: string;
                                    name: string;
                                };
                            };
                            upscaled: {
                                [key: string]: {
                                    assetId: string;
                                    heightPx: number;
                                    letteringUnreliable: boolean;
                                    widthPx: number;
                                };
                            };
                        } | null;
                        outcome: string;
                        result?: unknown;
                        status: number;
                    };
                };
            };
            /** @description Refused: invalid_input, invalid_body */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: unauthorized, member_link_required, member_link_revoked */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, feature_disabled, forbidden, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description The card was stale: what it would change moved since. Refused: turn_in_progress, conversation_moved, card_not_open */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        conversation: {
                            cards: {
                                [key: string]: {
                                    change?: {
                                        added: {
                                            label: string;
                                            renamedTo?: string;
                                            text?: string;
                                            type: string;
                                        }[];
                                        changed: {
                                            label: string;
                                            renamedTo?: string;
                                            text?: string;
                                            type: string;
                                        }[];
                                        removed: {
                                            label: string;
                                            renamedTo?: string;
                                            text?: string;
                                            type: string;
                                        }[];
                                        restyled: boolean;
                                    };
                                    current?: {
                                        name?: string;
                                    };
                                    estimate?: {
                                        availableCredits: number;
                                        credits: number;
                                    };
                                    input?: unknown;
                                    pictures?: {
                                        assetId: string;
                                        heightPx: number;
                                        letteringUnreliable: boolean;
                                        widthPx: number;
                                    }[];
                                    refusedWith?: string;
                                    runId?: string;
                                    savedRevisions?: {
                                        [key: string]: number;
                                    };
                                    showcases?: {
                                        baseId: string;
                                        before: {
                                            id: string;
                                            name: string;
                                            values: {
                                                [key: string]: {
                                                    [key: string]: unknown;
                                                };
                                            };
                                        }[];
                                        name: string;
                                    }[];
                                    status: string;
                                    tool: string;
                                    upscaleId?: string;
                                };
                            };
                            contentKeys: {
                                [key: string]: string;
                            };
                            id: string;
                            messages: ({
                                content: string | ({
                                    text: string;
                                    /** @enum {string} */
                                    type: "text";
                                } | {
                                    assetId: string;
                                    /** @enum {string} */
                                    type: "attachment";
                                } | {
                                    /** @enum {string} */
                                    type: "upload";
                                    uploadId: string;
                                } | {
                                    content: string | ({
                                        text: string;
                                        /** @enum {string} */
                                        type: "text";
                                    } | {
                                        of: {
                                            id: string;
                                            /** @enum {string} */
                                            kind: "template";
                                        } | {
                                            id: string;
                                            /** @enum {string} */
                                            kind: "design";
                                            revision: number;
                                        } | {
                                            id: string;
                                            /** @enum {string} */
                                            kind: "asset";
                                        } | {
                                            id: string;
                                            /** @enum {string} */
                                            kind: "upload";
                                        } | {
                                            id: string;
                                            /** @enum {string} */
                                            kind: "trial";
                                            values: {
                                                [key: string]: {
                                                    [key: string]: unknown;
                                                };
                                            };
                                        } | {
                                            blankId: string;
                                            id: string;
                                            /** @enum {string} */
                                            kind: "template_mockup";
                                            mockupId?: string;
                                            placementId: string;
                                            viewId?: string;
                                        } | {
                                            id: string;
                                            /** @enum {string} */
                                            kind: "design_mockup";
                                            mockupId?: string;
                                            placementId?: string;
                                            viewId?: string;
                                        };
                                        /** @enum {string} */
                                        type: "picture";
                                    })[];
                                    is_error?: boolean;
                                    tool_use_id: string;
                                    /** @enum {string} */
                                    type: "tool_result";
                                })[];
                                /** @enum {string} */
                                role: "user";
                            } | {
                                content: ({
                                    text: string;
                                    /** @enum {string} */
                                    type: "text";
                                } | {
                                    id: string;
                                    input?: unknown;
                                    name: string;
                                    /** @enum {string} */
                                    type: "tool_use";
                                } | {
                                    id: string;
                                    input?: unknown;
                                    name: string;
                                    /** @enum {string} */
                                    type: "server_tool_use";
                                } | {
                                    content: {
                                        tool_references: {
                                            tool_name: string;
                                            type: string;
                                        }[];
                                        /** @enum {string} */
                                        type: "tool_search_tool_search_result";
                                    } | {
                                        error_code: string;
                                        /** @enum {string} */
                                        type: "tool_search_tool_result_error";
                                    };
                                    tool_use_id: string;
                                    /** @enum {string} */
                                    type: "tool_search_tool_result";
                                })[];
                                /** @enum {string} */
                                role: "assistant";
                            })[];
                            unavailable: string[];
                            unseen: string[];
                            uploads: {
                                [key: string]: {
                                    kind: string;
                                    name: string;
                                };
                            };
                            upscaled: {
                                [key: string]: {
                                    assetId: string;
                                    heightPx: number;
                                    letteringUnreliable: boolean;
                                    widthPx: number;
                                };
                            };
                        } | null;
                        outcome: string;
                        result?: unknown;
                        status: number;
                    } | {
                        error: string;
                    };
                };
            };
            /** @description The confirming route refused the card. Refused: payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        conversation: {
                            cards: {
                                [key: string]: {
                                    change?: {
                                        added: {
                                            label: string;
                                            renamedTo?: string;
                                            text?: string;
                                            type: string;
                                        }[];
                                        changed: {
                                            label: string;
                                            renamedTo?: string;
                                            text?: string;
                                            type: string;
                                        }[];
                                        removed: {
                                            label: string;
                                            renamedTo?: string;
                                            text?: string;
                                            type: string;
                                        }[];
                                        restyled: boolean;
                                    };
                                    current?: {
                                        name?: string;
                                    };
                                    estimate?: {
                                        availableCredits: number;
                                        credits: number;
                                    };
                                    input?: unknown;
                                    pictures?: {
                                        assetId: string;
                                        heightPx: number;
                                        letteringUnreliable: boolean;
                                        widthPx: number;
                                    }[];
                                    refusedWith?: string;
                                    runId?: string;
                                    savedRevisions?: {
                                        [key: string]: number;
                                    };
                                    showcases?: {
                                        baseId: string;
                                        before: {
                                            id: string;
                                            name: string;
                                            values: {
                                                [key: string]: {
                                                    [key: string]: unknown;
                                                };
                                            };
                                        }[];
                                        name: string;
                                    }[];
                                    status: string;
                                    tool: string;
                                    upscaleId?: string;
                                };
                            };
                            contentKeys: {
                                [key: string]: string;
                            };
                            id: string;
                            messages: ({
                                content: string | ({
                                    text: string;
                                    /** @enum {string} */
                                    type: "text";
                                } | {
                                    assetId: string;
                                    /** @enum {string} */
                                    type: "attachment";
                                } | {
                                    /** @enum {string} */
                                    type: "upload";
                                    uploadId: string;
                                } | {
                                    content: string | ({
                                        text: string;
                                        /** @enum {string} */
                                        type: "text";
                                    } | {
                                        of: {
                                            id: string;
                                            /** @enum {string} */
                                            kind: "template";
                                        } | {
                                            id: string;
                                            /** @enum {string} */
                                            kind: "design";
                                            revision: number;
                                        } | {
                                            id: string;
                                            /** @enum {string} */
                                            kind: "asset";
                                        } | {
                                            id: string;
                                            /** @enum {string} */
                                            kind: "upload";
                                        } | {
                                            id: string;
                                            /** @enum {string} */
                                            kind: "trial";
                                            values: {
                                                [key: string]: {
                                                    [key: string]: unknown;
                                                };
                                            };
                                        } | {
                                            blankId: string;
                                            id: string;
                                            /** @enum {string} */
                                            kind: "template_mockup";
                                            mockupId?: string;
                                            placementId: string;
                                            viewId?: string;
                                        } | {
                                            id: string;
                                            /** @enum {string} */
                                            kind: "design_mockup";
                                            mockupId?: string;
                                            placementId?: string;
                                            viewId?: string;
                                        };
                                        /** @enum {string} */
                                        type: "picture";
                                    })[];
                                    is_error?: boolean;
                                    tool_use_id: string;
                                    /** @enum {string} */
                                    type: "tool_result";
                                })[];
                                /** @enum {string} */
                                role: "user";
                            } | {
                                content: ({
                                    text: string;
                                    /** @enum {string} */
                                    type: "text";
                                } | {
                                    id: string;
                                    input?: unknown;
                                    name: string;
                                    /** @enum {string} */
                                    type: "tool_use";
                                } | {
                                    id: string;
                                    input?: unknown;
                                    name: string;
                                    /** @enum {string} */
                                    type: "server_tool_use";
                                } | {
                                    content: {
                                        tool_references: {
                                            tool_name: string;
                                            type: string;
                                        }[];
                                        /** @enum {string} */
                                        type: "tool_search_tool_search_result";
                                    } | {
                                        error_code: string;
                                        /** @enum {string} */
                                        type: "tool_search_tool_result_error";
                                    };
                                    tool_use_id: string;
                                    /** @enum {string} */
                                    type: "tool_search_tool_result";
                                })[];
                                /** @enum {string} */
                                role: "assistant";
                            })[];
                            unavailable: string[];
                            unseen: string[];
                            uploads: {
                                [key: string]: {
                                    kind: string;
                                    name: string;
                                };
                            };
                            upscaled: {
                                [key: string]: {
                                    assetId: string;
                                    heightPx: number;
                                    letteringUnreliable: boolean;
                                    widthPx: number;
                                };
                            };
                        } | null;
                        outcome: string;
                        result?: unknown;
                        status: number;
                    } | {
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
            /** @description Refused: apply_failed */
            503: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
        };
    };
    "pixelConversation.get": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The open conversation, or null when the author has none */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        conversation: {
                            cards: {
                                [key: string]: {
                                    change?: {
                                        added: {
                                            label: string;
                                            renamedTo?: string;
                                            text?: string;
                                            type: string;
                                        }[];
                                        changed: {
                                            label: string;
                                            renamedTo?: string;
                                            text?: string;
                                            type: string;
                                        }[];
                                        removed: {
                                            label: string;
                                            renamedTo?: string;
                                            text?: string;
                                            type: string;
                                        }[];
                                        restyled: boolean;
                                    };
                                    current?: {
                                        name?: string;
                                    };
                                    estimate?: {
                                        availableCredits: number;
                                        credits: number;
                                    };
                                    input?: unknown;
                                    pictures?: {
                                        assetId: string;
                                        heightPx: number;
                                        letteringUnreliable: boolean;
                                        widthPx: number;
                                    }[];
                                    refusedWith?: string;
                                    runId?: string;
                                    savedRevisions?: {
                                        [key: string]: number;
                                    };
                                    showcases?: {
                                        baseId: string;
                                        before: {
                                            id: string;
                                            name: string;
                                            values: {
                                                [key: string]: {
                                                    [key: string]: unknown;
                                                };
                                            };
                                        }[];
                                        name: string;
                                    }[];
                                    status: string;
                                    tool: string;
                                    upscaleId?: string;
                                };
                            };
                            contentKeys: {
                                [key: string]: string;
                            };
                            id: string;
                            messages: ({
                                content: string | ({
                                    text: string;
                                    /** @enum {string} */
                                    type: "text";
                                } | {
                                    assetId: string;
                                    /** @enum {string} */
                                    type: "attachment";
                                } | {
                                    /** @enum {string} */
                                    type: "upload";
                                    uploadId: string;
                                } | {
                                    content: string | ({
                                        text: string;
                                        /** @enum {string} */
                                        type: "text";
                                    } | {
                                        of: {
                                            id: string;
                                            /** @enum {string} */
                                            kind: "template";
                                        } | {
                                            id: string;
                                            /** @enum {string} */
                                            kind: "design";
                                            revision: number;
                                        } | {
                                            id: string;
                                            /** @enum {string} */
                                            kind: "asset";
                                        } | {
                                            id: string;
                                            /** @enum {string} */
                                            kind: "upload";
                                        } | {
                                            id: string;
                                            /** @enum {string} */
                                            kind: "trial";
                                            values: {
                                                [key: string]: {
                                                    [key: string]: unknown;
                                                };
                                            };
                                        } | {
                                            blankId: string;
                                            id: string;
                                            /** @enum {string} */
                                            kind: "template_mockup";
                                            mockupId?: string;
                                            placementId: string;
                                            viewId?: string;
                                        } | {
                                            id: string;
                                            /** @enum {string} */
                                            kind: "design_mockup";
                                            mockupId?: string;
                                            placementId?: string;
                                            viewId?: string;
                                        };
                                        /** @enum {string} */
                                        type: "picture";
                                    })[];
                                    is_error?: boolean;
                                    tool_use_id: string;
                                    /** @enum {string} */
                                    type: "tool_result";
                                })[];
                                /** @enum {string} */
                                role: "user";
                            } | {
                                content: ({
                                    text: string;
                                    /** @enum {string} */
                                    type: "text";
                                } | {
                                    id: string;
                                    input?: unknown;
                                    name: string;
                                    /** @enum {string} */
                                    type: "tool_use";
                                } | {
                                    id: string;
                                    input?: unknown;
                                    name: string;
                                    /** @enum {string} */
                                    type: "server_tool_use";
                                } | {
                                    content: {
                                        tool_references: {
                                            tool_name: string;
                                            type: string;
                                        }[];
                                        /** @enum {string} */
                                        type: "tool_search_tool_search_result";
                                    } | {
                                        error_code: string;
                                        /** @enum {string} */
                                        type: "tool_search_tool_result_error";
                                    };
                                    tool_use_id: string;
                                    /** @enum {string} */
                                    type: "tool_search_tool_result";
                                })[];
                                /** @enum {string} */
                                role: "assistant";
                            })[];
                            unavailable: string[];
                            unseen: string[];
                            uploads: {
                                [key: string]: {
                                    kind: string;
                                    name: string;
                                };
                            };
                            upscaled: {
                                [key: string]: {
                                    assetId: string;
                                    heightPx: number;
                                    letteringUnreliable: boolean;
                                    widthPx: number;
                                };
                            };
                        } | null;
                        /** @description Whether a turn, or a card being applied, holds the conversation now: one still running after the panel that asked for it closed. Read again until it is false to see what it did. */
                        working: boolean;
                    };
                };
            };
            /** @description Refused: unauthorized, member_link_required, member_link_revoked */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, feature_disabled, forbidden, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "pixel.designer": {
        parameters: {
            query?: never;
            header?: {
                /** @description The designer's browser session, which the SDK sends so one visitor's uploads and proofs are told apart from another's on the same key: 6 to 64 letters, digits, `_` or `-`. Any other value is ignored. */
                "x-pixonaut-session"?: string;
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description What the customer asks Pixel, in their own words. */
                    prompt: string;
                    /** @description The template version the designer shows, `baseId@version`. */
                    templateId: string;
                    /**
                     * @description The customer's values as the designer holds them, by layer id and then prop, as a proof sends them.
                     * @default {}
                     */
                    values?: {
                        [key: string]: {
                            [key: string]: unknown;
                        };
                    };
                };
            };
        };
        responses: {
            /** @description The customer's values with Pixel's changes */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Each field Pixel changed, in the order it first changed. */
                        changed: {
                            layerId: string;
                            prop: string;
                        }[];
                        /** @description Each picture Pixel is cutting out of its background: read `GET /v1/assets/{id}/cut-out` with its `assetId` until it is done, then put the cut-out in its place. */
                        cutOuts: {
                            assetId: string;
                            layerId: string;
                            prop: string;
                        }[];
                        /** @description What Pixel says it did, for the customer, in their language. */
                        reply: string;
                        /** @description The customer's values with Pixel's changes applied: what the designer shows next. */
                        values: {
                            [key: string]: {
                                [key: string]: unknown;
                            };
                        };
                    };
                };
            };
            /** @description Refused: no_session, invalid_input */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `invalid_input`. */
                        reason?: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
            /** @description Refused: lock_timeout, pixel_unavailable */
            503: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
        };
    };
    "pixelDismissals.create": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description The card to dismiss. Without one, the conversation itself is ended, so the next turn with no conversation starts a new one. */
                    cardId?: string;
                    conversationId: string;
                };
            };
        };
        responses: {
            /** @description The card was dismissed, and Pixel told */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        conversation: {
                            cards: {
                                [key: string]: {
                                    change?: {
                                        added: {
                                            label: string;
                                            renamedTo?: string;
                                            text?: string;
                                            type: string;
                                        }[];
                                        changed: {
                                            label: string;
                                            renamedTo?: string;
                                            text?: string;
                                            type: string;
                                        }[];
                                        removed: {
                                            label: string;
                                            renamedTo?: string;
                                            text?: string;
                                            type: string;
                                        }[];
                                        restyled: boolean;
                                    };
                                    current?: {
                                        name?: string;
                                    };
                                    estimate?: {
                                        availableCredits: number;
                                        credits: number;
                                    };
                                    input?: unknown;
                                    pictures?: {
                                        assetId: string;
                                        heightPx: number;
                                        letteringUnreliable: boolean;
                                        widthPx: number;
                                    }[];
                                    refusedWith?: string;
                                    runId?: string;
                                    savedRevisions?: {
                                        [key: string]: number;
                                    };
                                    showcases?: {
                                        baseId: string;
                                        before: {
                                            id: string;
                                            name: string;
                                            values: {
                                                [key: string]: {
                                                    [key: string]: unknown;
                                                };
                                            };
                                        }[];
                                        name: string;
                                    }[];
                                    status: string;
                                    tool: string;
                                    upscaleId?: string;
                                };
                            };
                            contentKeys: {
                                [key: string]: string;
                            };
                            id: string;
                            messages: ({
                                content: string | ({
                                    text: string;
                                    /** @enum {string} */
                                    type: "text";
                                } | {
                                    assetId: string;
                                    /** @enum {string} */
                                    type: "attachment";
                                } | {
                                    /** @enum {string} */
                                    type: "upload";
                                    uploadId: string;
                                } | {
                                    content: string | ({
                                        text: string;
                                        /** @enum {string} */
                                        type: "text";
                                    } | {
                                        of: {
                                            id: string;
                                            /** @enum {string} */
                                            kind: "template";
                                        } | {
                                            id: string;
                                            /** @enum {string} */
                                            kind: "design";
                                            revision: number;
                                        } | {
                                            id: string;
                                            /** @enum {string} */
                                            kind: "asset";
                                        } | {
                                            id: string;
                                            /** @enum {string} */
                                            kind: "upload";
                                        } | {
                                            id: string;
                                            /** @enum {string} */
                                            kind: "trial";
                                            values: {
                                                [key: string]: {
                                                    [key: string]: unknown;
                                                };
                                            };
                                        } | {
                                            blankId: string;
                                            id: string;
                                            /** @enum {string} */
                                            kind: "template_mockup";
                                            mockupId?: string;
                                            placementId: string;
                                            viewId?: string;
                                        } | {
                                            id: string;
                                            /** @enum {string} */
                                            kind: "design_mockup";
                                            mockupId?: string;
                                            placementId?: string;
                                            viewId?: string;
                                        };
                                        /** @enum {string} */
                                        type: "picture";
                                    })[];
                                    is_error?: boolean;
                                    tool_use_id: string;
                                    /** @enum {string} */
                                    type: "tool_result";
                                })[];
                                /** @enum {string} */
                                role: "user";
                            } | {
                                content: ({
                                    text: string;
                                    /** @enum {string} */
                                    type: "text";
                                } | {
                                    id: string;
                                    input?: unknown;
                                    name: string;
                                    /** @enum {string} */
                                    type: "tool_use";
                                } | {
                                    id: string;
                                    input?: unknown;
                                    name: string;
                                    /** @enum {string} */
                                    type: "server_tool_use";
                                } | {
                                    content: {
                                        tool_references: {
                                            tool_name: string;
                                            type: string;
                                        }[];
                                        /** @enum {string} */
                                        type: "tool_search_tool_search_result";
                                    } | {
                                        error_code: string;
                                        /** @enum {string} */
                                        type: "tool_search_tool_result_error";
                                    };
                                    tool_use_id: string;
                                    /** @enum {string} */
                                    type: "tool_search_tool_result";
                                })[];
                                /** @enum {string} */
                                role: "assistant";
                            })[];
                            unavailable: string[];
                            unseen: string[];
                            uploads: {
                                [key: string]: {
                                    kind: string;
                                    name: string;
                                };
                            };
                            upscaled: {
                                [key: string]: {
                                    assetId: string;
                                    heightPx: number;
                                    letteringUnreliable: boolean;
                                    widthPx: number;
                                };
                            };
                        };
                    };
                };
            };
            /** @description The conversation was ended, or had ended already */
            204: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Refused: invalid_body */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: unauthorized, member_link_required, member_link_revoked */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, feature_disabled, forbidden, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: conversation_not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: turn_in_progress, conversation_moved, card_not_open */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "pixelTurns.create": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    conversationId: string | null;
                    openTemplate: {
                        /** @description The template's base id, as list_templates returns it. */
                        baseId: string;
                        revision: number;
                    } | null;
                    page: {
                        id: string;
                        /** @enum {string} */
                        kind: "templates" | "inks" | "shapes" | "palettes" | "blanks" | "designs" | "prints" | "orders";
                    } | null;
                    /** @description A connected store's own tools, which it runs itself, each `{ name, description, inputSchema }`: the name under the store's prefix (`woo_` for WooCommerce), the input schema a JSON Schema of an object. When Pixel calls one, the stream gives a `tool_call` event and ends paused, and the store posts the result to the turn's tool results. Only an integration key declares them; a declaration that is not one is refused `invalid_tools`. */
                    tools?: unknown[];
                    /** @description The author's new words, or null to carry on the turn that paused at its cards once every one of them is decided. */
                    words: {
                        attachments: string[];
                        text: string;
                        /** @default [] */
                        uploads?: string[];
                    } | null;
                };
            };
        };
        responses: {
            /** @description The turn's events, one per `PixelTurnEvent`, until the turn ends */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "text/event-stream": string;
                };
            };
            /** @description Refused: invalid_body */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: unauthorized, member_link_required, member_link_revoked */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: insufficient_credits. The tenant's credits cannot cover this action, its spending cap has no room left for it, a storefront's customer asked and the tenant's daily storefront ceiling has no room left, or the account that created the tenant has not confirmed its email address yet, so none of it was done. `reason` says which: `balance`, `spending_cap`, `storefront_ceiling` or `email_unverified`. `requiredCredits`, `availableCredits` and `reason` are left out for a publishable key. */
            402: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Always sent with `insufficient_credits`. */
                        availableCredits?: number;
                        error: string;
                        /** @description Always sent with `insufficient_credits`. */
                        reason?: string;
                        /** @description Always sent with `insufficient_credits`. */
                        requiredCredits?: number;
                    };
                };
            };
            /** @description Refused: origin_forbidden, feature_disabled, forbidden, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: turn_in_progress, conversation_moved, not_paused */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: unknown_upload, invalid_tools, payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Sent with `payload_too_large`. */
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "pixelTurns.toolResults.create": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                turnId: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description The `tool_call` event's `callId`. */
                    callId: string;
                    /** @description What the tool answered, any JSON value. */
                    output: unknown;
                } | {
                    /** @description The `tool_call` event's `callId`. */
                    callId: string;
                    error: {
                        message: string;
                    };
                };
            };
        };
        responses: {
            /** @description The turn's events, one per `PixelTurnEvent`, until it ends or pauses again */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "text/event-stream": string;
                };
            };
            /** @description Refused: invalid_body */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: unauthorized, member_link_required, member_link_revoked */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: insufficient_credits. The tenant's credits cannot cover this action, its spending cap has no room left for it, a storefront's customer asked and the tenant's daily storefront ceiling has no room left, or the account that created the tenant has not confirmed its email address yet, so none of it was done. `reason` says which: `balance`, `spending_cap`, `storefront_ceiling` or `email_unverified`. `requiredCredits`, `availableCredits` and `reason` are left out for a publishable key. */
            402: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Always sent with `insufficient_credits`. */
                        availableCredits?: number;
                        error: string;
                        /** @description Always sent with `insufficient_credits`. */
                        reason?: string;
                        /** @description Always sent with `insufficient_credits`. */
                        requiredCredits?: number;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: call_not_pending */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "prints.list": {
        parameters: {
            query?: {
                /** @description The page to read, from 1; the first when left out. */
                page?: number;
                pageSize?: number;
                /** @description Only prints in any of these statuses: `created` is still being made, `completed` is ready to order, `failed` could not be made. Repeat it, or separate them with commas (`completed,created`, the prints an order can be placed of). */
                status?: string | string[];
                apiKeyId?: string;
                /** @description Only the prints made from this design: its id, as list_designs returns it. */
                designId?: string;
                /** @description Only the prints whose number, template name or design id holds this text, case aside. */
                q?: string;
                /** @description How the list sorts: `newest` first (the default), `oldest` first, or by what each print's files take in storage, `largest` or `smallest` first. A print with no stored size sorts last either way. */
                sort?: "newest" | "oldest" | "largest" | "smallest";
                pageOf?: string;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description A page of prints */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description How many prints each status holds under every filter but `status`, for a status filter that says what each choice holds. */
                        counts: {
                            completed: number;
                            created: number;
                            failed: number;
                        };
                        page: number;
                        pageSize: number;
                        prints: {
                            api_key_id: string | null;
                            /** @description The bleed around the trim in millimetres. Null until the print completes, and for a template that names no blank. */
                            bleedMm: number | null;
                            completed_at: number | null;
                            created_at: number;
                            /** @description The design's `revision` now. A print whose `design_revision` is lower is of an older revision, and cannot be ordered. */
                            currentRevision: number;
                            design_id: string;
                            /** @description The design's `revision` this print rendered. Only a print of the design's current revision can be ordered; one made before a correction is refused `print_superseded`. */
                            design_revision: number;
                            /** @description Whose fault a failed print's failure is. Null for a print that did not fail, and for one that failed before the reason was kept. */
                            failure: {
                                /** @description Whose the fault is: `design` when the design must change before it can be printed, `ours` when the renderer failed and trying again will probably fail the same way. */
                                owner: string;
                            } | null;
                            /** @description How many bytes the print's stored files take in the workspace's storage; null while it renders, once its files are deleted, and for a print made before sizes were kept. */
                            filesBytes: number | null;
                            /** @description How many files the print keeps, null whenever `filesBytes` is. */
                            filesCount: number | null;
                            /** @description When the print's files were deleted, after its design's personal data was erased or by a member to free storage; null while they are kept. The print stays as a record. */
                            filesErasedAt: number | null;
                            /** @description The print's trimmed height in millimetres. Null until the print completes. */
                            heightMm: number | null;
                            id: string;
                            /** @description The print number its files are named after, such as `PR-2026-381042`. Null for a print made before numbers were kept that never completed. */
                            number: string | null;
                            /** @description How many orders hold the print. 0 for a print never ordered, and for a studio member without `orders:read`. */
                            orderCount: number;
                            /** @description The distinct names of the printshops the print's orders went to, first-sent first: two connections sharing a name appear once. Empty for a studio member without `orders:read`. */
                            printshops: string[];
                            status: string;
                            /** @description The name of the template the print was made from. Null until the print completes. */
                            templateName: string | null;
                            /** @description The version of that template the print was rendered from. Null until the print completes. */
                            templateVersion: number | null;
                            /** @description The print's trimmed width in millimetres. Null until the print completes. */
                            widthMm: number | null;
                        }[];
                        total: number;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: invalid_query */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "prints.create": {
        parameters: {
            query?: never;
            header?: {
                /** @description Your own key for this request. A repeat with the same key and body within 24 hours is answered with what the first one made, marked `Idempotent-Replayed: true`, and makes nothing; the same key with another body is refused `idempotency_key_reused`, and a repeat while the first is still being answered `idempotency_key_in_use`. A request that is refused makes nothing, so its key may be sent again. */
                "idempotency-key"?: string;
                /** @description `wait` answers once the print has rendered: `201` with its job ticket, or `render_failed`. Without it the print is answered `202` as soon as it is reserved, and renders after the answer. */
                prefer?: string;
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    designId: string;
                    /** @description The design's `hasPrint` as the caller read it. `false` refuses `already_printed` when the design's current text has been printed since, so it is not printed twice by someone who did not know. */
                    expectedHasPrint?: boolean;
                    /**
                     * @deprecated
                     * @description No longer accepted: the consumer's reference is the order's. Send it to POST /v1/prints/{id}/orders.
                     */
                    externalRef?: unknown;
                    /**
                     * @deprecated
                     * @description No longer accepted: the quantity is the order's. Send it to POST /v1/prints/{id}/orders.
                     */
                    quantity?: unknown;
                };
            };
        };
        responses: {
            /** @description With `Prefer: wait`: the print, rendered, and its job ticket */
            201: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        jobTicket: {
                            artifact: {
                                colorSpace: string;
                                cut?: {
                                    bleedMm: number;
                                    cropMarks: boolean;
                                    cutLine: boolean;
                                    cutName: string | null;
                                    markOffsetMm: number;
                                    mirrored: boolean;
                                    part: string;
                                    profile: string;
                                    registrationMarks: string;
                                    underbase: {
                                        chokeMm: number;
                                        coverage: string;
                                        spotName: string;
                                    } | null;
                                    varnish: {
                                        coverage: string;
                                        spotName: string;
                                    } | null;
                                };
                                effectiveDpi: number;
                                file: string;
                                format: string;
                                iccProfile: string;
                                includesBleed: boolean;
                                spotColors: string[];
                                spotOutput: string;
                                trimMarks: boolean;
                            };
                            artwork: {
                                name?: string;
                                templateId: string;
                            } | {
                                fillColour: string;
                                name: string;
                            };
                            fulfilmentPayload?: unknown;
                            manifest: {
                                docHash: string;
                                fontSetHash: string;
                                iccProfile: string;
                                renderedAt: string;
                                rendererVersion: string;
                                templateVersion?: string;
                            };
                            printArea: {
                                anchor?: {
                                    /** @description How the print aligns to the reference: `top-left`, `top-center`, `top-right`, `center-left`, `center`, `center-right`, `bottom-left`, `bottom-center` or `bottom-right`. Anything else is read as `center`. */
                                    align: string;
                                    /** @description How far the print is moved from the reference, in millimetres. y grows downward. */
                                    offsetMm: {
                                        /** @description Horizontal offset in millimetres; positive moves right. */
                                        x: number;
                                        /** @description Vertical offset in millimetres; positive moves down. */
                                        y: number;
                                    };
                                    /** @description The physical reference the print is positioned against on the product. */
                                    reference: string;
                                };
                                bleedMm?: number;
                                cutShape: {
                                    d: string;
                                    type: string;
                                };
                                heightMm: number;
                                /** @description The linked group the design is one placement of: one design drives every placement it names. Absent for a design on one placement alone. */
                                linked?: {
                                    /** @description Whether this placement's print is mirrored left to right. */
                                    mirrored: boolean;
                                    /** @description The group's placements, by id. */
                                    placements: string[];
                                    /** @description The width of the group's widest print area, in mm: what a repeat across the group is sized against, so it prints at one physical scale on every placement. */
                                    referenceWidthMm: number;
                                };
                                printMethod?: string;
                                printedAs?: string;
                                /** @description The repeat the print was drawn as: the design's mode, size and seed, and the printed size of the tile laid across the print. Absent for a print that does not repeat. */
                                repeat?: {
                                    /** @description How the tiles are laid: `grid` lines them up, `brick` moves every other row along by half a tile, `halfDrop` moves every other column down by half a tile, and `scatter` strews them at random places, turns and sizes, arranged by `seed`. */
                                    mode: string;
                                    /** @description Which arrangement a `scatter` draws: another seed is another arrangement of the same tile. Read by `scatter` only. */
                                    seed: number;
                                    /** @description The tile's width in percent of the print area's width, above 0 and at most 100; the tile keeps the template's shape. A tile that would print under 10 mm on a side is drawn at 10 mm. */
                                    size: number;
                                    /** @description The tile's printed height in millimetres. */
                                    unitHeightMm: number;
                                    /** @description The tile's printed width in millimetres. */
                                    unitWidthMm: number;
                                };
                                safeAreaMm?: number;
                                shape?: {
                                    /** @description True when the print shop cuts the product to this shape: the outline and the cut-outs go into the print file as its cut line. Omitted, the product already has the shape. */
                                    cutByPrintShop?: boolean;
                                    /** @description The shape as SVG path data in fractions of the print area, 0 to 1 across and down (curves, no arcs): its first subpath the outline, every further one a cut-out, filled even-odd, each subpath closed. */
                                    dFrac: string;
                                };
                                widthMm: number;
                            };
                            product: {
                                sku: string;
                                tenantId: string;
                            };
                        };
                        printId: string;
                    };
                };
            };
            /** @description The print, reserved and rendering */
            202: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    /** @description The print, at `GET /v1/prints/{id}`. */
                    location: string;
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        printId: string;
                        /** @description The print is rendering. Read it at `Location` until it is `completed` or `failed`, or wait for `print.completed` or `print.failed`. */
                        status: string;
                    };
                };
            };
            /** @description Refused: bad_request, quantity_moved_to_order, external_ref_moved_to_order */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: plan_limit_reached, origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                        /** @description The limit the tenant is at: `templates`, `connectedStores`, `apiKeys`, `shareLinks`, `customDomains`, `printsMadePerMonth` (prints made without an order this month), `members`, `orders` (this month's orders, which getting a print's files without an order counts as), or a sandbox's own caps: `sandboxPrintsPerDay`, `sandboxPrintsPerMonth`, `sandboxOrdersPerMonth`. A sandbox shares every other limit with its live workspace. Always sent with `plan_limit_reached`. */
                        limit?: string;
                        /** @description How many the plan allows. Always sent with `plan_limit_reached`. */
                        max?: number;
                        /** @description The plan whose limit it is. Always sent with `plan_limit_reached`. */
                        plan?: string;
                    };
                };
            };
            /** @description Refused: design_not_found, not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: design_erased, design_not_approved, already_printed, idempotency_key_in_use */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: idempotency_key_reused, invalid_idempotency_key, payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Sent with `payload_too_large`. */
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: render_failed, db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Always sent with `render_failed`. */
                        detail?: string;
                        error: string;
                        /** @description The print the render left `failed`. Always sent with `render_failed`. */
                        printId?: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
            /** @description Refused: lock_timeout */
            503: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
        };
    };
    "prints.get": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The print, with its job ticket once it has completed */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        api_key_id: string | null;
                        artifacts: unknown;
                        /** @description The bleed around the trim in millimetres. Null until the print completes, and for a template that names no blank. */
                        bleedMm: number | null;
                        completed_at: number | null;
                        created_at: number;
                        /** @description The design's `revision` now. A print whose `design_revision` is lower is of an older revision, and cannot be ordered. */
                        currentRevision: number;
                        design_id: string;
                        /** @description The design's `revision` this print rendered. Only a print of the design's current revision can be ordered; one made before a correction is refused `print_superseded`. */
                        design_revision: number;
                        /** @description Why a failed print failed. Null for a print that did not fail, and for one that failed before the reason was kept. */
                        failure: {
                            /** @description The sentence the print's creation was answered with: what to change, for the design's fault. */
                            detail: string;
                            /** @description Whose the fault is: `design` when the design must change before it can be printed, `ours` when the renderer failed and trying again will probably fail the same way. */
                            owner: string;
                        } | null;
                        /** @description A link to the print's file that opens with no key, for an hour or two: to hand to a printshop or open in a browser. Null while it renders, when it failed, and once its files are deleted. */
                        fileUrl: string | null;
                        /** @description How many bytes the print's stored files take in the workspace's storage; null while it renders, once its files are deleted, and for a print made before sizes were kept. */
                        filesBytes: number | null;
                        /** @description How many files the print keeps, null whenever `filesBytes` is. */
                        filesCount: number | null;
                        /** @description When the print's files were deleted, after its design's personal data was erased or by a member to free storage; null while they are kept. The print stays as a record. */
                        filesErasedAt: number | null;
                        /** @description The print's trimmed height in millimetres. Null until the print completes. */
                        heightMm: number | null;
                        id: string;
                        jobTicket: {
                            artifact: {
                                colorSpace: string;
                                cut?: {
                                    bleedMm: number;
                                    cropMarks: boolean;
                                    cutLine: boolean;
                                    cutName: string | null;
                                    markOffsetMm: number;
                                    mirrored: boolean;
                                    part: string;
                                    profile: string;
                                    registrationMarks: string;
                                    underbase: {
                                        chokeMm: number;
                                        coverage: string;
                                        spotName: string;
                                    } | null;
                                    varnish: {
                                        coverage: string;
                                        spotName: string;
                                    } | null;
                                };
                                effectiveDpi: number;
                                file: string;
                                format: string;
                                iccProfile: string;
                                includesBleed: boolean;
                                spotColors: string[];
                                spotOutput: string;
                                trimMarks: boolean;
                            };
                            artwork: {
                                name?: string;
                                templateId: string;
                            } | {
                                fillColour: string;
                                name: string;
                            };
                            fulfilmentPayload?: unknown;
                            manifest: {
                                docHash: string;
                                fontSetHash: string;
                                iccProfile: string;
                                renderedAt: string;
                                rendererVersion: string;
                                templateVersion?: string;
                            };
                            printArea: {
                                anchor?: {
                                    /** @description How the print aligns to the reference: `top-left`, `top-center`, `top-right`, `center-left`, `center`, `center-right`, `bottom-left`, `bottom-center` or `bottom-right`. Anything else is read as `center`. */
                                    align: string;
                                    /** @description How far the print is moved from the reference, in millimetres. y grows downward. */
                                    offsetMm: {
                                        /** @description Horizontal offset in millimetres; positive moves right. */
                                        x: number;
                                        /** @description Vertical offset in millimetres; positive moves down. */
                                        y: number;
                                    };
                                    /** @description The physical reference the print is positioned against on the product. */
                                    reference: string;
                                };
                                bleedMm?: number;
                                cutShape: {
                                    d: string;
                                    type: string;
                                };
                                heightMm: number;
                                /** @description The linked group the design is one placement of: one design drives every placement it names. Absent for a design on one placement alone. */
                                linked?: {
                                    /** @description Whether this placement's print is mirrored left to right. */
                                    mirrored: boolean;
                                    /** @description The group's placements, by id. */
                                    placements: string[];
                                    /** @description The width of the group's widest print area, in mm: what a repeat across the group is sized against, so it prints at one physical scale on every placement. */
                                    referenceWidthMm: number;
                                };
                                printMethod?: string;
                                printedAs?: string;
                                /** @description The repeat the print was drawn as: the design's mode, size and seed, and the printed size of the tile laid across the print. Absent for a print that does not repeat. */
                                repeat?: {
                                    /** @description How the tiles are laid: `grid` lines them up, `brick` moves every other row along by half a tile, `halfDrop` moves every other column down by half a tile, and `scatter` strews them at random places, turns and sizes, arranged by `seed`. */
                                    mode: string;
                                    /** @description Which arrangement a `scatter` draws: another seed is another arrangement of the same tile. Read by `scatter` only. */
                                    seed: number;
                                    /** @description The tile's width in percent of the print area's width, above 0 and at most 100; the tile keeps the template's shape. A tile that would print under 10 mm on a side is drawn at 10 mm. */
                                    size: number;
                                    /** @description The tile's printed height in millimetres. */
                                    unitHeightMm: number;
                                    /** @description The tile's printed width in millimetres. */
                                    unitWidthMm: number;
                                };
                                safeAreaMm?: number;
                                shape?: {
                                    /** @description True when the print shop cuts the product to this shape: the outline and the cut-outs go into the print file as its cut line. Omitted, the product already has the shape. */
                                    cutByPrintShop?: boolean;
                                    /** @description The shape as SVG path data in fractions of the print area, 0 to 1 across and down (curves, no arcs): its first subpath the outline, every further one a cut-out, filled even-odd, each subpath closed. */
                                    dFrac: string;
                                };
                                widthMm: number;
                            };
                            product: {
                                sku: string;
                                tenantId: string;
                            };
                        } | null;
                        jobTicketStale: boolean;
                        /** @description The print number its files are named after, such as `PR-2026-381042`. Null for a print made before numbers were kept that never completed. */
                        number: string | null;
                        /** @description Where an order placed for this print goes when it names no printshop: its blank's printshop, else the printshop its design was committed with, else the tenant's default. An order of a print on no blank whose design was committed with none may name one (`printshopId`), which goes before the default; a print on a blank always goes to the blank's. `null` when none of them names one, so an order naming none is refused. Absent when the print is not completed, the caller may not read orders, or it could not be worked out. */
                        orderPrintshop?: {
                            id: string;
                            /** @description The merchant's own label for the connection. */
                            name: string;
                            /** @description `usable`, or why an order there is refused: `disconnected`, `unavailable` when its integration is no longer registered, or `paused` when the merchant paused it (an order there is refused `409 printshop_paused`). */
                            status: string;
                        } | null;
                        status: string;
                        /** @description The name of the template the print was made from. Null until the print completes. */
                        templateName: string | null;
                        /** @description The version of that template the print was rendered from. Null until the print completes. */
                        templateVersion: number | null;
                        tenant_id: string;
                        /** @description The print's trimmed width in millimetres. Null until the print completes. */
                        widthMm: number | null;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "prints.files.bundle": {
        parameters: {
            query?: {
                /** @description Sets of files to add beside the print's own, as a JSON array: each `{"machineProfile": "<id>"}`, a machine profile of the tenant's printshops, or `{"settings": {…}}`, output settings for this download only. At most 10. */
                add?: string;
            };
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The print's files, zipped */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/zip": string;
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: plan_limit_reached, order_balance_empty, forbidden, origin_forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                        /** @description The limit the tenant is at: `templates`, `connectedStores`, `apiKeys`, `shareLinks`, `customDomains`, `printsMadePerMonth` (prints made without an order this month), `members`, `orders` (this month's orders, which getting a print's files without an order counts as), or a sandbox's own caps: `sandboxPrintsPerDay`, `sandboxPrintsPerMonth`, `sandboxOrdersPerMonth`. A sandbox shares every other limit with its live workspace. Always sent with `plan_limit_reached`. */
                        limit?: string;
                        /** @description How many the plan allows. Always sent with `plan_limit_reached`. */
                        max?: number;
                        /** @description The plan whose limit it is. Always sent with `plan_limit_reached`. */
                        plan?: string;
                    };
                };
            };
            /** @description Refused: print_not_found, machine_profile_not_found, file_not_found, not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: ink_mask_missing, print_profile_unavailable, print_raster_too_large, invalid_query */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `print_raster_too_large`. */
                        reason?: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "prints.files.get": {
        parameters: {
            query?: {
                machineProfile?: string;
                settings?: string;
                part?: "combined" | "print" | "cut";
                file?: "process" | "separated";
            };
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The print file */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/pdf": string;
                    "image/png": string;
                    "image/tiff": string;
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: plan_limit_reached, order_balance_empty, forbidden, origin_forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                        /** @description The limit the tenant is at: `templates`, `connectedStores`, `apiKeys`, `shareLinks`, `customDomains`, `printsMadePerMonth` (prints made without an order this month), `members`, `orders` (this month's orders, which getting a print's files without an order counts as), or a sandbox's own caps: `sandboxPrintsPerDay`, `sandboxPrintsPerMonth`, `sandboxOrdersPerMonth`. A sandbox shares every other limit with its live workspace. Always sent with `plan_limit_reached`. */
                        limit?: string;
                        /** @description How many the plan allows. Always sent with `plan_limit_reached`. */
                        max?: number;
                        /** @description The plan whose limit it is. Always sent with `plan_limit_reached`. */
                        plan?: string;
                    };
                };
            };
            /** @description Refused: print_not_found, machine_profile_not_found, part_not_offered, separation_not_found, file_not_found, not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: ink_mask_missing, print_profile_unavailable, print_raster_too_large, invalid_query */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `print_raster_too_large`. */
                        reason?: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "prints.files.list": {
        parameters: {
            query?: {
                machineProfile?: string;
                settings?: string;
            };
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The print's files */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description How the print was counted as an order: its files got without one (`files`, when and by whom), or an order of it (`order`, when it was placed). Null when neither: the first get of its files counts as an order. Getting them again is free. */
                        counted: {
                            at: number;
                            by: {
                                kind: string;
                                name: string;
                                viaMcp: boolean;
                            } | null;
                            /** @enum {string} */
                            kind: "files";
                        } | {
                            at: number;
                            /** @enum {string} */
                            kind: "order";
                            orderId: string;
                        } | null;
                        machineProfileAskedId: string | null;
                        machineProfiles: {
                            id: string;
                            name: string;
                            printshop: string;
                        }[];
                        separationMissing: boolean;
                        settings: {
                            /** @description The bleed the file is trimmed to, in mm, or null for the bleed it was rendered with. */
                            bleedTrimMm: number | null;
                            /** @description Whether crop marks are drawn for a rectangular cut. */
                            cropMarks: boolean;
                            /** @description The name the cut path is drawn under, or null for a machine that cuts nothing. */
                            cutName: string | null;
                            /** @description How much further out than by default the marks sit, in mm. */
                            markOffsetMm: number;
                            /** @description Whether the print is mirrored. */
                            mirror: boolean;
                            /** @description The marks the machine reads off the printed sheet. */
                            registrationMarks: string;
                            /** @description A UV machine's white laid under the colour, or null for none. */
                            underbase: {
                                /** @description How far in from the inked edge the white stops, in mm; 0 leaves it to the RIP. */
                                chokeMm: number;
                                /** @description Where the white lies. */
                                coverage: string;
                                /** @description The spot name the printshop's RIP reads for this channel. */
                                spotName: string;
                            } | null;
                            /** @description A UV machine's varnish laid over the colour, or null for none. */
                            varnish: {
                                /** @description Where the varnish lies when the design marks no layer for spot varnish. */
                                coverage: string;
                                /** @description The spot name the printshop's RIP reads for this channel. */
                                spotName: string;
                            } | null;
                        } | null;
                        variants: {
                            file: string;
                            handedOut: boolean;
                            isDefault: boolean;
                            part: string;
                            url: string;
                        }[];
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: print_not_found, machine_profile_not_found, not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: invalid_query */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "prints.orders.create": {
        parameters: {
            query?: never;
            header?: {
                /** @description Your own key for this request. A repeat with the same key and body within 24 hours is answered with what the first one made, marked `Idempotent-Replayed: true`, and makes nothing; the same key with another body is refused `idempotency_key_reused`, and a repeat while the first is still being answered `idempotency_key_in_use`. A request that is refused makes nothing, so its key may be sent again. */
                "idempotency-key"?: string;
            };
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": {
                    /** @description How many orders this print had when the caller read it (`GET /v1/orders?printId=`'s `total`). When it has another number now, the order is refused `stale_update` with the count it has, and none is placed: a request sent again after an answer that was lost does not order twice. Absent skips the check. */
                    expectedOrderCount?: number;
                    /** @description The caller's own reference for this order, such as its order id in the shop. Kept exactly as sent and handed to the printshop. */
                    externalRef?: string;
                    /** @description The printshop to make this order, for a print with no blank whose design named none when it was committed. A print on a blank is made by the blank's printshop: naming another is refused with `printshop_differs_from_blank`, and naming the blank's own as an unknown field. Absent or `null`, a print with no blank goes to the printshop its design was committed with, else the tenant's default. */
                    printshopId?: string | null;
                    /**
                     * @description How many copies to order. A whole number of 1 or more; 1 when left out.
                     * @default 1
                     */
                    quantity?: number;
                    /** @description Who the order is for. Left out, the first order of a design takes what its customer gave. */
                    recipient?: {
                        /**
                         * Format: email
                         * @description The recipient's email address, for the carrier's notices.
                         */
                        email?: string;
                        /** @description The recipient's name as a parcel label carries it, a person's or a company's. Up to 200 characters. */
                        name: string;
                        /** @description The recipient's phone number as the customer gave it, with the country code when it has one. */
                        phone?: string;
                    };
                    /** @description Order the design again on purpose. A design has one live order (in any status but `failed` and `cancelled`): absent or false, an order of a design that has one is refused `409 design_already_ordered`, naming the design and its newest live order, and nothing is written. True places the order whatever orders the design has. */
                    reorder?: boolean;
                    /** @description The id of a failed order of this print that this order replaces, changing what it wants: another number of copies, reference, recipient, address or, for a print with no blank, printshop. Allowed under the rules `POST /v1/orders/{id}/retry` has, and refused as it refuses; the new order records which order it replaces. */
                    replacesOrderId?: string;
                    /** @description A saved address to ship to; the customer stays the recipient. null: the customer's. Left out: the workspace's setting. */
                    shipToAddressId?: string | null;
                    /** @description Where the order ships. Left out, the first order of a design takes what its customer gave. */
                    shippingAddress?: {
                        /** @description The city or town. */
                        city: string;
                        /** @description The company of a business address, which the parcel goes to; the recipient is who receives it. */
                        company?: string;
                        /** @description The country as a two-letter ISO 3166-1 code in capitals, such as `SE` or `US`. */
                        country: string;
                        /** @description The first line of the street address: street and number. */
                        line1: string;
                        /** @description The second line of the address: an apartment, floor or c/o. */
                        line2?: string;
                        /** @description The postal code as the country writes it, such as `111 22` or `SW1A 1AA`. Left out where the country has none; a printshop that needs one refuses the order `postal_code_required`. */
                        postalCode?: string;
                        /** @description The state, province or county, where the country uses one. */
                        region?: string;
                    };
                    /** @description The variant of the print's blank the order is for, by ref (`v_…`). Left out, a blank with exactly one variant orders that one, and one with several is refused `variant_required`. A ref of another blank is refused `variant_not_of_blank`, and a retired one `variant_retired`. The order keeps a copy of the variant as it was: its options and the printshop fields it was sent. */
                    variant?: string;
                } | null;
            };
        };
        responses: {
            /** @description The submitted order */
            201: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        adapter: string;
                        /** @description The blank `blankId` names, as it reads now; `null` as `blankId` is. */
                        blank: {
                            name: string;
                            /** @description Its option axes, in order: how a variant's `options` read, such as Color then Size. */
                            optionAxes: string[];
                            /** @description How many variants it has, retired ones included. */
                            variants: number;
                        } | null;
                        /** @description The blank the order's prints are on; `null` for prints on no blank, or an order placed before it was recorded. */
                        blankId: string | null;
                        /** @description The order's latest address change, made with `PATCH /v1/orders/{id}/delivery` after the order was sent; `null` for an order whose address never changed. */
                        delivery: {
                            /** @description When the change was made. */
                            at: number;
                            /** @description What the printshop made of the change: `sending` while it is being told, `accepted`, `refused` (the order keeps the address the printshop has), or `carried` when what the printshop had not been sent yet carries the new address, so nothing extra was sent. */
                            state: string;
                            /** @description The printshop's own answer to a refused change; `null` otherwise. */
                            words: string | null;
                        } | null;
                        /** @description The design the lead print was made from. */
                        designId: string;
                        externalOrderRef: string | null;
                        externalRef: string | null;
                        /** @description Why Pixonaut failed the order rather than its printshop, as a refusal code: `print_failed` (a print of it could not be made; `lastError` names it), `prints_timed_out` (its prints were not finished within three hours of placing it), or the refusal an order waiting for its prints met when it was handed on, such as `technique_not_offered`. `null` for an order its printshop refused, or one not failed. */
                        failureKind: string | null;
                        /** @description Why the order is `held`, while it is; `null` for an order not held. A held order is accepted and not handed to its printshop until the month resets with room for it or the workspace upgrades. */
                        hold: {
                            /** @description The plan's monthly order limit the order met. */
                            limit: number;
                            /** @description When the month resets (ISO 8601, UTC): the latest the order is released, if the new month has room for it. */
                            periodEnd: string;
                            /** @description Why it is held: `monthly_order_limit`, the workspace has placed the orders its plan includes this month. Show a reason you do not know as held without one, never as a failure. */
                            reason: string;
                        } | null;
                        id: string;
                        lastCheckedAt: number | null;
                        lastError: string | null;
                        personalDataErasedAt: number | null;
                        /** @description The order's lead print: the first of `printIds`, and the only one of an order of one print. */
                        printId: string;
                        /** @description Every print the order holds, the lead first: the prints of one item, each in its own placement on its blank. */
                        printIds: string[];
                        /** @description `printIds` with each print's design, placement and file. */
                        prints: ({
                            designId: string;
                            /** @description The revision of the design the print was made from: `GET /v1/designs/{id}/revisions/{revision}/image` draws it. */
                            designRevision: number;
                            /** @description The placement fields the printshop was sent for this print, from its position there; `null` for an order placed before they were recorded. */
                            placementFields: {
                                name: string;
                                /** @description Where the value came from: the variant's (or position's) own, the field's default, or nothing, sent empty. */
                                source: string;
                                value: string;
                            }[] | null;
                            /** @description The placement on its blank the print's design was committed for; `null` for a design with no blank, or one committed before placements were recorded. */
                            placementId: string | null;
                            printId: string;
                            /** @description Where on the item the print goes, by the name the order's printshop knows it by (its Printed as), recorded when the order was placed; `null` for a print on no blank, or an order placed before it was recorded. */
                            printedAs: string | null;
                            /** @description Which of this print's files the printshop was sent; `null` while the order waits for its prints (`awaiting_prints`). */
                            spotOutput: string | null;
                            /** @description Where the print has got to: `created` while it renders, which an order in `awaiting_prints` waits for, then `completed`, or `failed`. */
                            status: string;
                        } | {
                            /** @description A fill print is made from no design. */
                            designId: null;
                            /** @description A fill print: an optional placement of the blank the order left undesigned, printed flat in this colour (`#rrggbb`), its fill colour, at the placement's whole area. */
                            fillColour: string;
                            /** @description The placement fields the printshop was sent for this print, from its position there; `null` for an order placed before they were recorded. */
                            placementFields: {
                                name: string;
                                /** @description Where the value came from: the variant's (or position's) own, the field's default, or nothing, sent empty. */
                                source: string;
                                value: string;
                            }[] | null;
                            /** @description The placement on its blank the print's design was committed for; `null` for a design with no blank, or one committed before placements were recorded. */
                            placementId: string | null;
                            printId: string;
                            /** @description Where on the item the print goes, by the name the order's printshop knows it by (its Printed as), recorded when the order was placed; `null` for a print on no blank, or an order placed before it was recorded. */
                            printedAs: string | null;
                            /** @description Which of this print's files the printshop was sent; `null` while the order waits for its prints (`awaiting_prints`). */
                            spotOutput: string | null;
                            /** @description Where the print has got to: `created` while it renders, which an order in `awaiting_prints` waits for, then `completed`, or `failed`. */
                            status: string;
                        })[];
                        /** @description The printshop as it was when the order was placed: its name and kind (`adapter`). `null` for an order placed before it was recorded. */
                        printshopAsPlaced: {
                            adapter: string;
                            name: string;
                        } | null;
                        printshopConnectionId: string | null;
                        printshopName: string | null;
                        quantity: number;
                        /** @description Who the order is for: its customer. When `shipTo` is set, the order ships there and the customer is who it is finally for. */
                        recipient: {
                            /**
                             * Format: email
                             * @description The recipient's email address, for the carrier's notices.
                             */
                            email?: string;
                            /** @description The recipient's name as a parcel label carries it, a person's or a company's. Up to 200 characters. */
                            name: string;
                            /** @description The recipient's phone number as the customer gave it, with the country code when it has one. */
                            phone?: string;
                        } | null;
                        /** @description The order submitted to replace this one, which names it as `replacesOrderId`; `null` for none. */
                        replacedByOrderId: string | null;
                        /** @description The failed order this one was submitted to replace; `null` for an order that replaces none. */
                        replacesOrderId: string | null;
                        /** @description The workspace's saved address the order ships to, as it was when the order was placed; `null` for an order that ships to its customer's address. Its printshop is handed this address, and erasing the order's personal data leaves it. */
                        shipTo: {
                            address: {
                                /** @description The city or town. */
                                city: string;
                                /** @description The company of a business address, which the parcel goes to; the recipient is who receives it. */
                                company?: string;
                                /** @description The country as a two-letter ISO 3166-1 code in capitals, such as `SE` or `US`. */
                                country: string;
                                /** @description The first line of the street address: street and number. */
                                line1: string;
                                /** @description The second line of the address: an apartment, floor or c/o. */
                                line2?: string;
                                /** @description The postal code as the country writes it, such as `111 22` or `SW1A 1AA`. Left out where the country has none; a printshop that needs one refuses the order `postal_code_required`. */
                                postalCode?: string;
                                /** @description The state, province or county, where the country uses one. */
                                region?: string;
                            };
                            /** @description What the address is called in the workspace, such as `Warehouse`: unique there, case aside, and the name a parcel sent there is addressed to. Up to 200 characters. */
                            name: string;
                            /** @description The saved address the order ships to, by id. It may have been changed or removed since; `name` and `address` are what the order was placed with. */
                            savedAddressId: string;
                        } | null;
                        /** @description The customer's address. Where the order ships, unless `shipTo` is set. */
                        shippingAddress: {
                            /** @description The city or town. */
                            city: string;
                            /** @description The company of a business address, which the parcel goes to; the recipient is who receives it. */
                            company?: string;
                            /** @description The country as a two-letter ISO 3166-1 code in capitals, such as `SE` or `US`. */
                            country: string;
                            /** @description The first line of the street address: street and number. */
                            line1: string;
                            /** @description The second line of the address: an apartment, floor or c/o. */
                            line2?: string;
                            /** @description The postal code as the country writes it, such as `111 22` or `SW1A 1AA`. Left out where the country has none; a printshop that needs one refuses the order `postal_code_required`. */
                            postalCode?: string;
                            /** @description The state, province or county, where the country uses one. */
                            region?: string;
                        } | null;
                        spotOutput: string | null;
                        status: string;
                        submittedAt: number;
                        tenantId: string;
                        tracking: {
                            /** @description Who carries it, such as `DHL`. */
                            carrier?: string;
                            /** @description The shipment's tracking number. */
                            number: string;
                            /**
                             * Format: uri
                             * @description Where the shipment is followed: an https address.
                             */
                            url?: string;
                        } | null;
                        updatedAt: number;
                        /** @description The variant as it was when the order was placed: its options and the variant fields its printshop was sent. A later edit of the variant does not change it. */
                        variant: {
                            /** @description Each declared field, in the printshop's order, as it was sent. */
                            fields: {
                                name: string;
                                /** @description Where the value came from: the variant's (or position's) own, the field's default, or nothing, sent empty. */
                                source: string;
                                value: string;
                            }[];
                            options: {
                                [key: string]: string;
                            };
                            ref: string;
                        } | null;
                        /** @description The variant the order names; `null` as `blankId` is. */
                        variantRef: string | null;
                    };
                };
            };
            /** @description Refused: bad_request */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: plan_limit_reached, origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                        /** @description The limit the tenant is at: `templates`, `connectedStores`, `apiKeys`, `shareLinks`, `customDomains`, `printsMadePerMonth` (prints made without an order this month), `members`, `orders` (this month's orders, which getting a print's files without an order counts as), or a sandbox's own caps: `sandboxPrintsPerDay`, `sandboxPrintsPerMonth`, `sandboxOrdersPerMonth`. A sandbox shares every other limit with its live workspace. Always sent with `plan_limit_reached`. */
                        limit?: string;
                        /** @description How many the plan allows. Always sent with `plan_limit_reached`. */
                        max?: number;
                        /** @description The plan whose limit it is. Always sent with `plan_limit_reached`. */
                        plan?: string;
                    };
                };
            };
            /** @description Refused: print_not_found, order_not_found, not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: print_not_completed, print_needs_printshop, print_ticket_stale, print_superseded, print_files_deleted, design_erased, stale_update, design_already_ordered, printshop_paused, order_not_retryable, order_at_printshop, order_superseded, idempotency_key_in_use */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Always sent with `stale_update`. */
                        current?: number;
                        /** @description Always sent with `design_already_ordered`. */
                        designId?: string;
                        /** @description Always sent with `print_ticket_stale`. */
                        detail?: string;
                        error: string;
                        /** @description Always sent with `order_superseded`. */
                        newerOrderId?: string;
                        /** @description Always sent with `design_already_ordered`. */
                        orderId?: string;
                        /** @description Always sent with `printshop_paused`. */
                        reason?: string;
                        /** @description Always sent with `print_not_completed`, `order_not_retryable`. With `order_not_retryable`: one of `held`, `awaiting_prints`, `submitted`, `queued`, `printed`, `shipped`, `failed`, `outcome_unknown`, `cancelled`. */
                        status?: string;
                    };
                };
            };
            /** @description Refused: unknown_printshop, printshop_disconnected, printshop_unavailable, printshop_differs_from_blank, missing_fulfilment_keys, postal_code_required, saved_address_not_found, spot_plate_required, print_profile_unavailable, print_exceeds_position, print_not_position_size, print_exceeds_machine, print_raster_too_large, technique_not_offered, placement_unfilled, variant_not_of_blank, variant_retired, variant_required, field_value_missing, variant_not_of_design_row, print_without_placement, mixed_blanks, duplicate_placement, print_committed_elsewhere, printshop_cannot_combine, prints_disagree, idempotency_key_reused, invalid_idempotency_key, payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Sent with `payload_too_large`. */
                        bytes?: number;
                        /** @description Always sent with `spot_plate_required`. */
                        cause?: string;
                        /** @description Always sent with `variant_not_of_design_row`. */
                        designId?: string;
                        /** @description Always sent with `print_profile_unavailable`. */
                        detail?: string;
                        error: string;
                        /** @description Always sent with `field_value_missing`. */
                        field?: string;
                        /** @description Always sent with `field_value_missing`. */
                        fieldKind?: string;
                        /** @description Always sent with `prints_disagree`. */
                        key?: string;
                        /** @description Always sent with `print_exceeds_position`. */
                        largestMm?: {
                            heightMm: number;
                            widthMm: number;
                        };
                        /** @description Always sent with `print_exceeds_machine`, `print_raster_too_large`. */
                        machine?: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                        /** @description Always sent with `print_exceeds_machine`. */
                        mediaMm?: {
                            heightMm: number;
                            widthMm: number;
                        };
                        /** @description Always sent with `technique_not_offered`. */
                        method?: string;
                        /** @description Always sent with `missing_fulfilment_keys`. */
                        missing?: string[];
                        /** @description Always sent with `print_profile_unavailable`. */
                        outputProfile?: string;
                        /** @description Always sent with `print_exceeds_position`, `print_not_position_size`, `technique_not_offered`, `placement_unfilled`, and may be sent with `print_exceeds_machine`, `print_raster_too_large`. */
                        placement?: string;
                        /** @description Always sent with `duplicate_placement`. */
                        placementId?: string;
                        /** @description Always sent with `print_exceeds_position`, `print_not_position_size`, and may be sent with `field_value_missing`. */
                        position?: string;
                        /** @description Always sent with `print_profile_unavailable`, `print_without_placement`, `print_committed_elsewhere`. */
                        printId?: string;
                        /** @description Always sent with `technique_not_offered`. */
                        printMethods?: string[];
                        /** @description Always sent with `print_exceeds_position`, `print_not_position_size`, `print_exceeds_machine`. */
                        printMm?: {
                            heightMm: number;
                            widthMm: number;
                        };
                        /** @description Always sent with `print_exceeds_machine`, `print_raster_too_large`. */
                        printshop?: string;
                        /** @description Always sent with `unknown_printshop`, `printshop_disconnected`, `printshop_unavailable`, `printshop_differs_from_blank`, `print_exceeds_position`, `print_not_position_size`, `print_exceeds_machine`, `print_raster_too_large`, `technique_not_offered`, `placement_unfilled`, `variant_not_of_blank`, `variant_retired`, `variant_required`, `field_value_missing`, `variant_not_of_design_row`. */
                        reason?: string;
                        /** @description Always sent with `spot_plate_required`. */
                        references?: string[];
                        /** @description Always sent with `variant_not_of_design_row`. */
                        row?: {
                            [key: string]: string;
                        };
                        /** @description Always sent with `print_not_position_size`. */
                        sizeMm?: {
                            heightMm: number;
                            widthMm: number;
                        };
                        /** @description Always sent with `print_raster_too_large`. */
                        sizePx?: {
                            heightPx: number;
                            widthPx: number;
                        };
                        /** @description Always sent with `variant_not_of_blank`, `variant_retired`, `variant_not_of_design_row`. */
                        variant?: string;
                        /** @description Always sent with `variant_required`. */
                        variants?: number;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
            /** @description Refused: lock_timeout */
            503: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
        };
    };
    "printshopConnections.list": {
        parameters: {
            query?: {
                q?: string;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The connections, active first, and the adapters available. A key is answered each connection's id, name, adapter, whether it is active and whether it is the default, and nothing else. */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        adapters: {
                            adapter: string;
                            catalogue: boolean;
                            categories: boolean;
                            consent: {
                                configured: boolean;
                            } | null;
                            credentialGuide: {
                                requiredPermissions: string[];
                                tokenPageUrl: string;
                            } | null;
                            deliverySteps: boolean;
                            machineProfiles: boolean;
                            placeholders: string[];
                            spotPlates: boolean;
                            takesContact: boolean;
                        }[];
                        available: string[];
                        connections: {
                            /** @description Whether its merchant says it takes an order's address after the order was sent; read when `addressChanges` is `by_setting`. */
                            acceptsAddressUpdates: boolean;
                            active: boolean;
                            adapter: string;
                            /** @description The printshop's own address, for its contact details; null for none. Never where an order ships. */
                            address: {
                                /** @description The city or town. */
                                city: string;
                                /** @description The company of a business address, which the parcel goes to; the recipient is who receives it. */
                                company?: string;
                                /** @description The country as a two-letter ISO 3166-1 code in capitals, such as `SE` or `US`. */
                                country: string;
                                /** @description The first line of the street address: street and number. */
                                line1: string;
                                /** @description The second line of the address: an apartment, floor or c/o. */
                                line2?: string;
                                /** @description The postal code as the country writes it, such as `111 22` or `SW1A 1AA`. Left out where the country has none; a printshop that needs one refuses the order `postal_code_required`. */
                                postalCode?: string;
                                /** @description The state, province or county, where the country uses one. */
                                region?: string;
                            } | null;
                            /** @description Whether an order's address may change after it was sent: `always` for a printshop whose integration tells it, `by_setting` when `acceptsAddressUpdates` decides, `null` for never. */
                            addressChanges: string | null;
                            config?: unknown;
                            /**
                             * Format: email
                             * @description The contact person's email address; null for none. A delivery step may send to it as `{printshop.contact.email}`.
                             */
                            contactEmail: string | null;
                            /** @description Whether mail to `contactEmail` bounced, so none is sent to it until the address changes. */
                            contactEmailBounced: boolean;
                            /** @description The name of the person to reach at the printshop. Up to 200 characters; null for none. */
                            contactName: string | null;
                            /** @description The contact person's phone number as written; null for none. */
                            contactPhone: string | null;
                            counts: {
                                blanks: number | null;
                                openOrders: number | null;
                                orders: number | null;
                            };
                            createdAt: number;
                            /** @description Whether its printshop refused to renew its credentials: it needs its merchant to connect it again through the printshop's consent. */
                            credentialsLapsed: boolean;
                            id: string;
                            isDefault: boolean;
                            name: string;
                            needsPositions: boolean;
                            paused: boolean;
                            printMethods: string[];
                            printMethodsFixed: boolean;
                            secretNames: string[] | null;
                            updatedAt: number;
                        }[];
                    } | {
                        connections: {
                            active: boolean;
                            adapter: string;
                            id: string;
                            isDefault: boolean;
                            name: string;
                        }[];
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: invalid_query */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "proofs.create": {
        parameters: {
            query?: {
                /** @description The IANA timezone the template's dynamic values are resolved in, such as `Europe/Stockholm`: today's date there. Absent, the workspace's timezone. */
                tz?: string;
                /** @description The language the template's dynamic values are written in when their name names none, one of `en`, `sv`, `de`, `fr`, `es`, `nl`, `da`, `nb`, `fi`. Absent, the workspace's default language. A value whose name carries a language, `{date.long:sv}`, keeps it. */
                lang?: "en" | "sv" | "de" | "fr" | "es" | "nl" | "da" | "nb" | "fi";
            };
            header?: {
                /** @description The designer's browser session, which the SDK sends so one visitor's uploads and proofs are told apart from another's on the same key: 6 to 64 letters, digits, `_` or `-`. Any other value is ignored. */
                "x-pixonaut-session"?: string;
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description The id of a published template. */
                    templateId?: unknown;
                    /** @description The customer's values for the template's fields. */
                    values?: unknown;
                } & {
                    blankId?: string;
                    placementId?: string;
                } & {
                    /** @description The linked group the placement is designed as part of: every placement one design drives, this one among them, each with whether its print is mirrored. The print is mirrored when this placement's entry says so, and a repeat on it is laid at one physical scale across the group: the document records the group and the width of its widest placement's print area (`linked.referenceWidthMm`). Needs `blankId` and `placementId`; each placement must be one of the blank's. */
                    linked?: {
                        /** @description Placements one design drives, two at least. */
                        placements: {
                            /** @description Whether the placement's print is mirrored left to right. */
                            mirror?: boolean;
                            /** @description The id of one of the blank's placements. */
                            placementId: string;
                        }[];
                    };
                    placementId?: string;
                } & {
                    heightMm?: number;
                    widthMm?: number;
                } & {
                    /** @description Whether the designer drew the customer's canvas at the template's own ratio, as the SDK mount option of that name sets it. The design is made at the chosen size through the template's fit either way, so this changes nothing in what is made. */
                    drawAtTemplateRatio?: boolean;
                } & {
                    /** @description A variant of the blank, by ref (`v_…`). On a blank whose print areas change with its size, the design is sized at, and keeps, that variant's size; a ref the blank has no variant of is refused with `variant_not_of_blank`. On any other blank it is not checked. A proof also keeps it as `proof_variant`, for display. */
                    variant?: string;
                    /** @description The size the design is for, as the blank's option values, such as `{"Size": "XL"}`, in place of `variant`: a value of each option the blank's print areas change with, and nothing else, or it is refused with `variant_row_invalid`. Ignored on a blank whose print areas change with nothing. */
                    variantRow?: {
                        [key: string]: string;
                    };
                } & {
                    /** @description Lays the design as a repeat of its template across the print area. Null, or absent, places it once. Through a designer link, a repeat the link offers, or null where its shopper may turn the repeat off; absent there, the link's own start. */
                    repeat?: {
                        /**
                         * @description How the tiles are laid: `grid` lines them up, `brick` moves every other row along by half a tile, `halfDrop` moves every other column down by half a tile, and `scatter` strews them at random places, turns and sizes, arranged by `seed`.
                         * @enum {string}
                         */
                        mode: "grid" | "brick" | "halfDrop" | "scatter";
                        /** @description Which arrangement a `scatter` draws: another seed is another arrangement of the same tile. Read by `scatter` only. */
                        seed: number;
                        /** @description The tile's width in percent of the print area's width, above 0 and at most 100; the tile keeps the template's shape. A tile that would print under 10 mm on a side is drawn at 10 mm. */
                        size: number;
                    } | null;
                } & {
                    /** @description The view of the blank's placement the customer previewed the proof in, by id. Kept with the proof and read with the design's proof as `proof_view_id`, for display only. */
                    viewId?: string;
                };
            };
        };
        responses: {
            /** @description The proof, its image link and its token */
            201: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        docHash: string;
                        /** @description When the proof and its token expire, in milliseconds since the Unix epoch. */
                        expiresAt: number;
                        /** @description The pictures that print below `printFloorDpi` at the design's print size. A warning: nothing is refused for it. */
                        lowResolution: {
                            /** @description The picture's pixels along the edge that decides. */
                            actualPx: number;
                            assetId: string;
                            /** @description Pixels per inch along that edge, as printed. */
                            effectiveDpi: number;
                            /** @description The layer the picture fills, or the artwork's own key for its image background. */
                            layerId: string;
                            /** @description The pixels that edge needs at the floor. */
                            minPx: number;
                        }[];
                        /** @description The minimum print resolution the design's pictures were judged against: the template's own, else the tenant's. */
                        printFloorDpi: number;
                        proofToken: string;
                        proofUrl: string;
                    };
                };
            };
            /** @description Refused: bad_json, bad_request, invalid_query */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `invalid_query`. */
                        reason?: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, feature_disabled, forbidden, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: constraint_violation, unknown_placement, variant_not_of_blank, variant_row_invalid, asset_map_too_large, payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Always sent with `asset_map_too_large`, and may be sent with `payload_too_large`. */
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `asset_map_too_large`, `payload_too_large`. */
                        maxBytes?: number;
                        /** @description Always sent with `variant_not_of_blank`, `variant_row_invalid`. */
                        reason?: string;
                        /** @description Always sent with `variant_not_of_blank`. */
                        variant?: string;
                        /** @description Always sent with `constraint_violation`. */
                        violations?: {
                            /** @description On a `text_draws_fallback_glyphs` or `text_draws_missing_glyphs` warning: the characters the text's font cannot draw, each once, in the order the text first holds them. Absent on every other violation. */
                            characters?: string[];
                            given: unknown;
                            /** @description The language whose overrides break the rule, when only the template as it reads in that language does. Absent, the original. */
                            language?: string;
                            layerId: string;
                            prop: string;
                            rule: string;
                            /** @description `error` refuses a publish; `warning` is worth the author's attention and never does. */
                            severity: string;
                        }[];
                    };
                };
            };
            /** @description Refused: rate_limited, link_design_limit */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description When the link makes designs again: when the oldest design counted leaves the window. Null for a total limit. Always sent with `link_design_limit`. */
                        reopensAt?: number | null;
                    };
                };
            };
            /** @description The caller left before the render started */
            499: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
            /** @description Refused: assets_unavailable */
            503: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
        };
    };
    "proofs.createThroughLayout": {
        parameters: {
            query?: {
                /** @description The IANA timezone the template's dynamic values are resolved in, such as `Europe/Stockholm`: today's date there. Absent, the workspace's timezone. */
                tz?: string;
                /** @description The language the template's dynamic values are written in when their name names none, one of `en`, `sv`, `de`, `fr`, `es`, `nl`, `da`, `nb`, `fi`. Absent, the workspace's default language. A value whose name carries a language, `{date.long:sv}`, keeps it. */
                lang?: "en" | "sv" | "de" | "fr" | "es" | "nl" | "da" | "nb" | "fi";
            };
            header?: {
                /** @description The designer's browser session, which the SDK sends so one visitor's uploads and proofs are told apart from another's on the same key: 6 to 64 letters, digits, `_` or `-`. Any other value is ignored. */
                "x-pixonaut-session"?: string;
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    blankId: string;
                    /** @description The name of the blank's panel layout the design is drawn on. */
                    layout: string;
                    /** @description Lays the design as a repeat of its template across the print area. Null, or absent, places it once. Through a designer link, a repeat the link offers, or null where its shopper may turn the repeat off; absent there, the link's own start. */
                    repeat?: {
                        /**
                         * @description How the tiles are laid: `grid` lines them up, `brick` moves every other row along by half a tile, `halfDrop` moves every other column down by half a tile, and `scatter` strews them at random places, turns and sizes, arranged by `seed`.
                         * @enum {string}
                         */
                        mode: "grid" | "brick" | "halfDrop" | "scatter";
                        /** @description Which arrangement a `scatter` draws: another seed is another arrangement of the same tile. Read by `scatter` only. */
                        seed: number;
                        /** @description The tile's width in percent of the print area's width, above 0 and at most 100; the tile keeps the template's shape. A tile that would print under 10 mm on a side is drawn at 10 mm. */
                        size: number;
                    } | null;
                    /** @description The published template version, `<baseId>@<version>`. */
                    templateId: string;
                    /** @description The customer's values, as on `POST /v1/designs`. */
                    values?: {
                        [key: string]: unknown;
                    };
                    /** @description A variant of the blank, by ref (`v_…`). On a blank whose print areas change with its size, the design is sized at, and keeps, that variant's size; a ref the blank has no variant of is refused with `variant_not_of_blank`. On any other blank it is not checked. A proof also keeps it as `proof_variant`, for display. */
                    variant?: string;
                    /** @description The size the design is for, as the blank's option values, such as `{"Size": "XL"}`, in place of `variant`: a value of each option the blank's print areas change with, and nothing else, or it is refused with `variant_row_invalid`. Ignored on a blank whose print areas change with nothing. */
                    variantRow?: {
                        [key: string]: string;
                    };
                    /** @description The view of the blank the customer previewed the proof in, by id. Kept with the proof for display only. */
                    viewId?: string;
                };
            };
        };
        responses: {
            /** @description The proof, its image link and its token */
            201: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description The layout's canvas height at the size proofed, in mm. */
                        canvasHeightMm: number;
                        /** @description The layout's canvas width at the size proofed, in mm. */
                        canvasWidthMm: number;
                        docHash: string;
                        /** @description When the proof and its token expire, in milliseconds since the Unix epoch. */
                        expiresAt: number;
                        /** @description The pictures that print below `printFloorDpi` at the design's print size. A warning: nothing is refused for it. */
                        lowResolution: {
                            /** @description The picture's pixels along the edge that decides. */
                            actualPx: number;
                            assetId: string;
                            /** @description Pixels per inch along that edge, as printed. */
                            effectiveDpi: number;
                            /** @description The layer the picture fills, or the artwork's own key for its image background. */
                            layerId: string;
                            /** @description The pixels that edge needs at the floor. */
                            minPx: number;
                        }[];
                        /** @description The minimum print resolution the design's pictures were judged against: the template's own, else the tenant's. */
                        printFloorDpi: number;
                        proofToken: string;
                        proofUrl: string;
                    };
                };
            };
            /** @description Refused: bad_request, invalid_query */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `invalid_query`. */
                        reason?: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, feature_disabled, forbidden, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: layout_out_of_date */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `layout_out_of_date`. */
                        reason?: string;
                    };
                };
            };
            /** @description Refused: empty_layout, constraint_violation, unknown_placement, variant_not_of_blank, variant_row_invalid, asset_map_too_large, unknown_layout, payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Always sent with `asset_map_too_large`, and may be sent with `payload_too_large`. */
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `asset_map_too_large`, `payload_too_large`. */
                        maxBytes?: number;
                        /** @description Always sent with `variant_not_of_blank`, `variant_row_invalid`. */
                        reason?: string;
                        /** @description Always sent with `variant_not_of_blank`. */
                        variant?: string;
                        /** @description Always sent with `constraint_violation`. */
                        violations?: {
                            /** @description On a `text_draws_fallback_glyphs` or `text_draws_missing_glyphs` warning: the characters the text's font cannot draw, each once, in the order the text first holds them. Absent on every other violation. */
                            characters?: string[];
                            given: unknown;
                            /** @description The language whose overrides break the rule, when only the template as it reads in that language does. Absent, the original. */
                            language?: string;
                            layerId: string;
                            prop: string;
                            rule: string;
                            /** @description `error` refuses a publish; `warning` is worth the author's attention and never does. */
                            severity: string;
                        }[];
                    };
                };
            };
            /** @description Refused: rate_limited, link_design_limit */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description When the link makes designs again: when the oldest design counted leaves the window. Null for a total limit. Always sent with `link_design_limit`. */
                        reopensAt?: number | null;
                    };
                };
            };
            /** @description The caller left before the render started */
            499: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
            /** @description Refused: assets_unavailable */
            503: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
        };
    };
    "customerSessions.delete": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description What the wipe deleted, and to a secret key what it kept */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        assetsDeleted: number;
                        assetsRetained?: number;
                        proofsDeleted: number;
                        proofsRetained?: number;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, feature_disabled, forbidden, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "shareLinks.list": {
        parameters: {
            query?: {
                /** @description The page to read, from 1; the first when left out. */
                page?: number;
                pageSize?: number;
                pageOf?: string;
                /** @description Only the link holding this name, case aside: with `pageSize=1`, whether a name is free. */
                name?: string;
                /** @description Only the links about this template, design or order. */
                subjectId?: string;
                /** @description Only links of this kind. */
                kind?: "designer" | "proof-page" | "order-status" | "printshop" | "address-capture" | "correction";
                /** @description Only links handed out by `member`s, by a `key` (any secret key or connected store), by the key or store of this id, or `auto`: sent with an order to a custom printshop. */
                source?: string;
                /** @description Only the links the caller handed out. */
                createdBy?: "me";
                /** @description `true`, only links carrying one shopper's visit (`state`); `false`, only those that do not. */
                carriesVisit?: "true" | "false";
                /** @description Only links that stop working within this many days. */
                expiresWithin?: number;
                /** @description `true`, only links that never expire; `false`, only those that do. */
                neverExpires?: "true" | "false";
                /** @description Only links whose name, subject's name, link id, or member or key that handed it out holds this text, case aside. */
                q?: string;
                /** @description `created` (the default), newest first; `expires`, the soonest to stop working first, those that never do last. */
                sort?: "created" | "expires";
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description A page of links */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description What each filter's choices would answer, in this one read. */
                        counts: {
                            /** @description How many links in view carry one shopper's visit, under every filter but `carriesVisit`. */
                            carriesVisit: number;
                            /** @description Each kind the caller may manage, under every other filter. */
                            kinds: {
                                count: number;
                                kind: string;
                            }[];
                            /** @description Members and printshop orders, then each key or store with links in view, under every filter but `source`. */
                            sources: ({
                                count: number;
                                /** @enum {string} */
                                source: "member";
                            } | {
                                count: number;
                                /** @enum {string} */
                                source: "auto";
                            } | {
                                count: number;
                                /** @description Null for a key the deployment configures. */
                                key: {
                                    id: string;
                                    /** @description `sk` for a secret key, `ik` for a connected store; null once the key is gone. */
                                    kind: string | null;
                                    /** @description The key's label, or the store's; null once the key is gone. */
                                    name: string | null;
                                } | null;
                                /** @enum {string} */
                                source: "key";
                            })[];
                        };
                        links: {
                            /** @description The brand the link's page is drawn in; null for the workspace's default, whichever that is when it opens. */
                            brandId: string | null;
                            createdAt: number;
                            /** @description The member who handed it out; null when no member did. */
                            createdBy: {
                                name: string | null;
                                userId: string;
                            } | null;
                            /** @description The secret key or connected store that handed the link out. */
                            createdByKey: {
                                id: string;
                                /** @description `sk` for a secret key, `ik` for a connected store; null once the key is gone. */
                                kind: string | null;
                                /** @description The key's label, or the store's; null once the key is gone. */
                                name: string | null;
                            } | null;
                            /** @description How many designs a designer link may make; null for none. */
                            designLimit: {
                                /** @description How many designs the link may make in its period. */
                                count: number;
                                /** @description `total` counts every design the link made; `hour`, `day` and `week` the last 60 minutes, 24 hours or 7 days, rolling. */
                                period: string;
                                /** @description At the limit, when the link makes designs again; null below it, and for a total limit. */
                                reopensAt: number | null;
                                /** @description The designs the limit counts now: one per side approved, in the rolling window. */
                                used: number;
                            } | null;
                            /** @description How many designs a designer link made, one per side approved; null for any other kind. */
                            designs: number | null;
                            /** @description When the link stops working; null for one that never does. */
                            expiresAt: number | null;
                            id: string;
                            kind: string;
                            /** @description When its page last opened, to the hour; null for never. */
                            lastOpenedAt: number | null;
                            /** @description The language the link's page is shown in, which its `url` names as `?lang=<locale>`; null when it names none, and the page is shown in the workspace's default language. */
                            locale: string | null;
                            mayDecide: boolean;
                            /** @description The workspace's name for the link. */
                            name: string | null;
                            /** @description Whether a designer link's page draws the placement frame around the shopper's picture at rest; false for every other link. */
                            placementFrame: boolean;
                            /** @description Whether a designer link's page draws the print area's frame; false for every other link. */
                            printAreaFrame: boolean;
                            returnUrl: string | null;
                            /** @description Who handed it out: `member`; `key`, a secret key or connected store (`createdByKey`, null for a key the deployment configures); `auto`, sent with an order to a custom printshop. */
                            source: string;
                            /** @description What the link is about; null once it no longer exists. */
                            subject: {
                                /** @description The subject's name: a template's name; for a design, the name of its template; for an order, its external reference, null when it has none. */
                                label: string | null;
                                meta: {
                                    /** @description The blank its sides are printed on; null for none. */
                                    blank: {
                                        id: string;
                                        name: string | null;
                                    } | null;
                                    /** @description Whether the link carries one shopper's visit (`state`). */
                                    carriesVisit: boolean;
                                    /** @description The host its page sends a shopper back to; null for none. */
                                    returnHost: string | null;
                                    /** @description One entry per side, one for a link with one. */
                                    sides: {
                                        key: string | null;
                                        label: string | null;
                                        /** @description The sizes its menu offers; empty for none. */
                                        printSizes: {
                                            heightMm: number;
                                            label: string;
                                            widthMm: number;
                                        }[];
                                    }[];
                                    /** @enum {string} */
                                    type: "template";
                                } | {
                                    status: string;
                                    /** @enum {string} */
                                    type: "design";
                                } | {
                                    /** @description The printshop the order went to; null for none. */
                                    printshop: {
                                        id: string;
                                        name: string;
                                    } | null;
                                    status: string;
                                    /** @enum {string} */
                                    type: "order";
                                };
                                /** @description What keeps the page from opening for now: `template_paused` (it opens again once the template is live), `printshop_disconnected`; null for nothing. */
                                warning: string | null;
                            } | null;
                            subjectId: string;
                            /** @description A designer link's address, which it keeps: it sits on a store's page until withdrawn. It carries `?lang=<locale>` when the link names a `locale`. Null for every other kind, whose address is shown once, and for a designer link made before addresses were kept until it is regenerated. */
                            url: string | null;
                        }[];
                        page: number;
                        pageSize: number;
                        total: number;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, feature_disabled */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: invalid_query */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "shareLinks.create": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description The brand the link's page is drawn in: its name, logo and accent colour (`GET /v1/brands`). Refused `brand_not_found` unless it is one of the workspace's. Absent, a link a connected store's key hands out keeps the store's brand, and any other is drawn in whichever brand is the workspace's default when it opens. A brand a link that still opens names cannot be deleted. */
                    brandId?: string;
                    /** @description A designer only: how many designs its page may make, in total or per rolling hour, day or week. Each side approved counts one. At the limit the page, and an approval, answer `429 link_design_limit`. Refused `design_limit_not_allowed` for any other kind. Absent, no limit. */
                    designLimit?: {
                        /** @description How many designs the link may make in its period. */
                        count: number;
                        /**
                         * @description `total` counts every design the link made; `hour`, `day` and `week` the last 60 minutes, 24 hours or 7 days, rolling.
                         * @enum {string}
                         */
                        period: "total" | "hour" | "day" | "week";
                    };
                    /** @description How long the link works, in days. Absent, the kind's default; a designer then never expires. Each kind has a cap, named in the refusal when exceeded. */
                    expiresInDays?: number;
                    /**
                     * @description The page the link opens. A correction link is minted for its design by `POST /v1/designs/{id}/correction-links`.
                     * @enum {string}
                     */
                    kind: "designer" | "proof-page" | "order-status" | "printshop" | "address-capture";
                    /**
                     * @description A proof page only: the language it is shown in, one of `en`, `sv`, `de`, `fr`, `es`, `nl`, `da`, `nb`, `fi`. Absent, the page is shown in the workspace's default language. The link's `url` carries `?lang=<locale>` when it names one. Refused `locale_not_allowed` for any other kind.
                     * @enum {string}
                     */
                    locale?: "en" | "sv" | "de" | "fr" | "es" | "nl" | "da" | "nb" | "fi";
                    /** @description A proof page only: whether its holder may approve or reject the design. Handing that out takes `designs:update` as well as `designs:read`. */
                    mayDecide?: boolean;
                    /** @description The workspace's own name for the link (`Spring market stand`), at most 80 characters, never shown on its page. Trimmed, inner spaces made one; empty is no name. Unique among the workspace's working links, case aside: one another holds is refused `share_link_name_taken` naming the holder, a longer one `share_link_name_too_long`. A withdrawn or expired link frees its name. */
                    name?: string;
                    /** @description An address capture page only: the one order of the design its answer reads and changes, whatever orders of the design are placed later. Refused `order_not_found` unless it holds a print of the design (and, for a connected store, the store placed it), `order_closed` once it has shipped, will not be made or its personal data was erased, and `order_not_allowed` for any other kind. Absent, the page reads and changes the design's newest open order. */
                    orderId?: string;
                    /** @description A designer only: whether its page draws the placement frame, the ring and corner handles around the shopper's picture, at rest, as the SDK's `showPlacementFrame` does. Refused `placement_frame_not_allowed` for any other kind. Absent, the frame shows only while the picture is dragged or sized on the preview. */
                    placementFrame?: boolean;
                    /** @description A designer only: whether its page draws a thin frame around the print area on the product photo, as the SDK's `showPrintAreaFrame` does. Refused `print_area_frame_not_allowed` for any other kind. Absent, no frame. */
                    printAreaFrame?: boolean;
                    /** @description A proof page only: where it sends the customer once they have asked for changes, with `state`, so the store can open the design for editing. Refused `return_url_not_allowed` for any other kind: a designer that returns to a store is minted by `POST /v1/templates/{id}/designer-links`, a correction page by `POST /v1/designs/{id}/correction-links`. On one of the origins the tenant's publishable keys are allowed on. */
                    returnUrl?: string;
                    /** @description Carried back to `returnUrl` untouched, for the store to match the customer to its own session. Only with `returnUrl`. */
                    state?: string;
                    /** @description What the page is about: a template's base id for a designer, a design's id for a proof page or address capture, an order's id for an order status or printshop page. */
                    subjectId: string;
                };
            };
        };
        responses: {
            /** @description The new link */
            201: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description The brand the link's page is drawn in; null for the workspace's default, whichever that is when it opens. */
                        brandId: string | null;
                        createdAt: number;
                        /** @description How many designs a designer link may make; null for none. */
                        designLimit: {
                            /** @description How many designs the link may make in its period. */
                            count: number;
                            /** @description `total` counts every design the link made; `hour`, `day` and `week` the last 60 minutes, 24 hours or 7 days, rolling. */
                            period: string;
                        } | null;
                        /** @description When the link stops working; null for one that never does. */
                        expiresAt: number | null;
                        id: string;
                        kind: string;
                        /** @description The language the link's page is shown in, which its `url` names as `?lang=<locale>`; null when it names none, and the page is shown in the workspace's default language. */
                        locale: string | null;
                        mayDecide: boolean;
                        /** @description The workspace's name for the link. */
                        name: string | null;
                        /** @description Whether a designer link's page draws the placement frame around the shopper's picture at rest; false for every other link. */
                        placementFrame: boolean;
                        /** @description Whether a designer link's page draws the print area's frame; false for every other link. */
                        printAreaFrame: boolean;
                        returnUrl: string | null;
                        subjectId: string;
                        /** @description The link's token. Shown in this response only. */
                        token: string;
                        /** @description The hosted page the link opens, with `?lang=<locale>` when the link names a `locale`. */
                        url: string;
                    };
                };
            };
            /** @description Refused: decide_not_allowed, return_url_not_allowed, return_url_not_https, return_url_off_store, locale_not_allowed, design_limit_not_allowed, print_area_frame_not_allowed, placement_frame_not_allowed, order_not_allowed, expiry_too_long, invalid_input */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `expiry_too_long`. */
                        kind?: string;
                        /** @description Always sent with `expiry_too_long`. */
                        maxDays?: number;
                        /** @description Always sent with `invalid_input`. */
                        reason?: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: plan_limit_reached, origin_forbidden, feature_disabled */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                        /** @description The limit the tenant is at: `templates`, `connectedStores`, `apiKeys`, `shareLinks`, `customDomains`, `printsMadePerMonth` (prints made without an order this month), `members`, `orders` (this month's orders, which getting a print's files without an order counts as), or a sandbox's own caps: `sandboxPrintsPerDay`, `sandboxPrintsPerMonth`, `sandboxOrdersPerMonth`. A sandbox shares every other limit with its live workspace. Always sent with `plan_limit_reached`. */
                        limit?: string;
                        /** @description How many the plan allows. Always sent with `plan_limit_reached`. */
                        max?: number;
                        /** @description The plan whose limit it is. Always sent with `plan_limit_reached`. */
                        plan?: string;
                    };
                };
            };
            /** @description Refused: subject_not_found, order_not_found, brand_not_found, not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: share_link_name_taken, order_closed */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Always sent with `order_closed`. */
                        closed?: string;
                        error: string;
                        /** @description The link holding the name. Always sent with `share_link_name_taken`. */
                        holderId?: string | null;
                    };
                };
            };
            /** @description Refused: share_link_name_too_long, payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Sent with `payload_too_large`. */
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                        /** @description The longest name a link may have. Always sent with `share_link_name_too_long`. */
                        maxLength?: number;
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
            /** @description Refused: lock_timeout */
            503: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
        };
    };
    "shareLinks.revokeMany": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description The links to withdraw, at most 100. */
                    ids: string[];
                } | {
                    /** @description The secret key or connected store whose working links to withdraw. The key keeps working, and may hand out new links. */
                    createdByKeyId: string;
                };
            };
        };
        responses: {
            /** @description What was withdrawn */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description One entry per id asked for, in order, each once. */
                        results: {
                            id: string;
                            /** @description `revoked`: the link no longer works. `not_found`: no working link of that id the caller may manage — unknown, already withdrawn, or not theirs. */
                            outcome: string;
                        }[];
                    } | {
                        /** @description How many of the key's working links were withdrawn. */
                        revoked: number;
                    };
                };
            };
            /** @description Refused: invalid_input */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, feature_disabled */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "shareLinks.delete": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The link no longer works */
            204: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, feature_disabled */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "shareLinks.update": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description The blank it is printed on; with placementId, or a panelLayout. */
                    blankId?: string;
                    /** @description A designer link's new design limit; null removes it. Refused `design_limit_not_allowed` for any other kind. */
                    designLimit?: {
                        /** @description How many designs the link may make in its period. */
                        count: number;
                        /**
                         * @description `total` counts every design the link made; `hour`, `day` and `week` the last 60 minutes, 24 hours or 7 days, rolling.
                         * @enum {string}
                         */
                        period: "total" | "hour" | "day" | "week";
                    } | null;
                    /** @description How long a designer link works from the change, in days, up to 365; null, until withdrawn. Absent, it keeps its expiry. Refused `expiry_fixed_by_state` while the link carries `state`. */
                    expiresInDays?: number | null;
                    /** @description The variant the side starts on, by ref: one of `variants` when it names any. */
                    initialVariant?: string;
                    /** @description The view shown first; absent, the side's first with a photo. */
                    initialView?: string;
                    /**
                     * @description How every side's form lays out its steps: `page`, every step on one page, or `steps`, one step at a time. Absent, each side's form follows its template's own `form.layout`, and is a page when the template names none.
                     * @enum {string}
                     */
                    layout?: "page" | "steps";
                    /** @description Which of the sides' placements one design drives, such as a sweater's sleeves: a preset, or groups of the sides' placements, a group with a repeat of its own where it repeats apart from the link. The sides of one group print one template. Absent, the groups the blank suggests whose sides print one template; the link keeps the groups it was made with. */
                    linkedPlacements?: {
                        /** @description Whether the shopper may take a placement out of its group and design it on its own. Absent, no. */
                        designSeparately?: boolean;
                        /** @description Groups of your own in place of a preset, each a list of placements, or `{ placements, repeat }` for a group that repeats apart from the link. A mirror left out is the blank's suggestion, else none. */
                        groups?: ({
                            /** @description Whether the placement's print is mirrored left to right. */
                            mirror?: boolean;
                            /** @description The id of one of the blank's placements. */
                            placementId: string;
                        }[] | {
                            /** @description Placements one design drives, two at least. */
                            placements: {
                                /** @description Whether the placement's print is mirrored left to right. */
                                mirror?: boolean;
                                /** @description The id of one of the blank's placements. */
                                placementId: string;
                            }[];
                            /** @description How the group's design is laid as a repeat, in place of the link's `repeat`; null places it once beside a link that repeats. */
                            repeat: {
                                /** @description The layouts the shopper may pick, one at least, each once. */
                                modes: ("grid" | "brick" | "halfDrop" | "scatter")[];
                                /** @description Whether the shopper may pick another of `modes` and another size. Otherwise every design prints as `start`. */
                                shopperMayChange: boolean;
                                /** @description Whether the shopper may place the design once instead (`repeat: null`). Only with `shopperMayChange`. */
                                shopperMayTurnOff: boolean;
                                /** @description What the design starts as: a repeat in one of `modes`, or null for placed once, which needs `shopperMayTurnOff`. A request through the link that names no repeat is made with it. */
                                start: {
                                    /**
                                     * @description How the tiles are laid: `grid` lines them up, `brick` moves every other row along by half a tile, `halfDrop` moves every other column down by half a tile, and `scatter` strews them at random places, turns and sizes, arranged by `seed`.
                                     * @enum {string}
                                     */
                                    mode: "grid" | "brick" | "halfDrop" | "scatter";
                                    /** @description Which arrangement a `scatter` draws: another seed is another arrangement of the same tile. Read by `scatter` only. */
                                    seed: number;
                                    /** @description The tile's width in percent of the print area's width, above 0 and at most 100; the tile keeps the template's shape. A tile that would print under 10 mm on a side is drawn at 10 mm. */
                                    size: number;
                                } | null;
                            } | null;
                        })[];
                        /**
                         * @description `each`: every placement is designed on its own. `suggested`: the groups the blank suggests, such as its sleeves. `all`: one design drives every placement. Absent with no `groups`, `suggested`.
                         * @enum {string}
                         */
                        preset?: "each" | "suggested" | "all";
                    };
                    /**
                     * @description The language a designer link's page is shown in; null for the workspace's default. An address copied before that names a language (`?lang=`) keeps showing it: copy the link's `url` again.
                     * @enum {string|null}
                     */
                    locale?: "en" | "sv" | "de" | "fr" | "es" | "nl" | "da" | "nb" | "fi" | null;
                    /** @description The store's own product photos the design is shown on, in place of the blank's views. */
                    mockups?: {
                        /** @description How far the photo's folds move the design, above 0 and at most 1; absent or null, not at all. */
                        displacementStrength?: number | null;
                        /** @description What the menu calls the photo. */
                        label: string;
                        /** @description The label per customer-facing language, by code: only the languages it has one in. A designer shown in a language left out reads `label`. */
                        localizedLabels?: {
                            da?: string;
                            de?: string;
                            en?: string;
                            es?: string;
                            fi?: string;
                            fr?: string;
                            nb?: string;
                            nl?: string;
                            sv?: string;
                        };
                        /** @description The size of the photo the rect is measured in, when it is not the size of the image the url serves; absent, the image's own. */
                        photoSizePx?: {
                            /** @description Its height, in pixels. */
                            h: number;
                            /** @description Its width, in pixels. */
                            w: number;
                        };
                        /** @description Where the print sits in the photo, in the photo's pixels. */
                        placementRectPx: {
                            /** @description Its height, in the photo's pixels. */
                            h: number;
                            /** @description Its width, in the photo's pixels. */
                            w: number;
                            /** @description From the photo's left edge, in its pixels. */
                            x: number;
                            /** @description From the photo's top edge, in its pixels. */
                            y: number;
                        };
                        /** @description How strongly the photo's light and shade carry onto the design, from 0 (flat) to 1; absent, the default. */
                        shadingStrength?: number;
                        /**
                         * Format: uri
                         * @description The photo's address, http or https.
                         */
                        url: string;
                        /** @description The store's own name for the way the product is photographed: photos sharing one are one view. */
                        viewId?: string;
                        /** @description How the design wraps round the product in the photo, a mug or a bottle; absent or null, flat. */
                        warp?: {
                            /** @description How far round the product the rect reaches, above 0 and at most 1. */
                            curvature: number;
                            /** @description How dark the design turns toward the product's silhouette, 0 to 1. */
                            edgeFalloff?: number;
                            /**
                             * @description The one kind of wrap: an upright round product.
                             * @enum {string}
                             */
                            kind: "cylinder";
                        } | null;
                    }[];
                    /** @description The link's new name; null removes it. Unique among the workspace's working links, case aside. */
                    name?: string | null;
                    /** @description The name of a panel layout of the link's `blankId`, in place of `placementId`: the page draws one design across the layout's canvas, and each placement it lays out gets its print cut from it, so art runs across the seams. Not with `sides` or `printSizes`. */
                    panelLayout?: string;
                    /** @description Whether the link's page draws the placement frame, the ring and corner handles around the shopper's picture, at rest, as the SDK's `showPlacementFrame` does. Absent, the frame shows only while the picture is dragged or sized on the preview. */
                    placementFrame?: boolean;
                    /** @description The blank's placement it is printed in; with blankId. */
                    placementId?: string;
                    /** @description Whether the link's page draws a thin frame around the print area on the product photo, as the SDK's `showPrintAreaFrame` does. Absent, no frame. */
                    printAreaFrame?: boolean;
                    /** @description The sizes the shopper picks from, for a print within its area. */
                    printSizes?: {
                        /** @description The print's height, in mm. */
                        heightMm: number;
                        /** @description What the menu calls the size. */
                        label: string;
                        /** @description The label per customer-facing language, by code: only the languages it has one in. A designer shown in a language left out reads `label`. */
                        localizedLabels?: {
                            da?: string;
                            de?: string;
                            en?: string;
                            es?: string;
                            fi?: string;
                            fr?: string;
                            nb?: string;
                            nl?: string;
                            sv?: string;
                        };
                        /** @description The print's width, in mm. */
                        widthMm: number;
                    }[];
                    /** @description Whether every side's design is laid as a repeat of its template, which layouts the shopper may pick, what it starts as, and whether they may change it or turn it off; a linked group with a repeat of its own takes that instead. Absent, each design is placed once and a request through the link naming a repeat is refused. Not with `panelLayout`. */
                    repeat?: {
                        /** @description The layouts the shopper may pick, one at least, each once. */
                        modes: ("grid" | "brick" | "halfDrop" | "scatter")[];
                        /** @description Whether the shopper may pick another of `modes` and another size. Otherwise every design prints as `start`. */
                        shopperMayChange: boolean;
                        /** @description Whether the shopper may place the design once instead (`repeat: null`). Only with `shopperMayChange`. */
                        shopperMayTurnOff: boolean;
                        /** @description What the design starts as: a repeat in one of `modes`, or null for placed once, which needs `shopperMayTurnOff`. A request through the link that names no repeat is made with it. */
                        start: {
                            /**
                             * @description How the tiles are laid: `grid` lines them up, `brick` moves every other row along by half a tile, `halfDrop` moves every other column down by half a tile, and `scatter` strews them at random places, turns and sizes, arranged by `seed`.
                             * @enum {string}
                             */
                            mode: "grid" | "brick" | "halfDrop" | "scatter";
                            /** @description Which arrangement a `scatter` draws: another seed is another arrangement of the same tile. Read by `scatter` only. */
                            seed: number;
                            /** @description The tile's width in percent of the print area's width, above 0 and at most 100; the tile keeps the template's shape. A tile that would print under 10 mm on a side is drawn at 10 mm. */
                            size: number;
                        } | null;
                    };
                    /** @description Where a designer link's page sends the shopper back to, as `POST /v1/templates/{id}/designer-links` takes it; null removes it, and its `state` with it. On one of the origins the tenant's publishable keys are allowed on. */
                    returnUrl?: string | null;
                    /** @description The photo that starts selected, by its place in mockups. */
                    selectedMockupIndex?: number;
                    /** @description The size that starts selected, by its place in printSizes. */
                    selectedPrintSizeIndex?: number;
                    /** @description Several sides of one item, a front and a back, each its own template and placement, designed one after the other; then the one-side fields go on each side instead. */
                    sides?: {
                        /** @description The blank it is printed on; with placementId, or a panelLayout. */
                        blankId?: string;
                        /** @description The variant the side starts on, by ref: one of `variants` when it names any. */
                        initialVariant?: string;
                        /** @description The view shown first; absent, the side's first with a photo. */
                        initialView?: string;
                        /** @description The side's own short name, such as front: lowercase letters, digits, - and _, unique within the link. */
                        key: string;
                        /** @description What the side's step is called, such as Front. */
                        label: string;
                        /** @description The label per customer-facing language, by code: only the languages it has one in. A designer shown in a language left out reads `label`. */
                        localizedLabels?: {
                            da?: string;
                            de?: string;
                            en?: string;
                            es?: string;
                            fi?: string;
                            fr?: string;
                            nb?: string;
                            nl?: string;
                            sv?: string;
                        };
                        /** @description The store's own product photos the design is shown on, in place of the blank's views. */
                        mockups?: {
                            /** @description How far the photo's folds move the design, above 0 and at most 1; absent or null, not at all. */
                            displacementStrength?: number | null;
                            /** @description What the menu calls the photo. */
                            label: string;
                            /** @description The label per customer-facing language, by code: only the languages it has one in. A designer shown in a language left out reads `label`. */
                            localizedLabels?: {
                                da?: string;
                                de?: string;
                                en?: string;
                                es?: string;
                                fi?: string;
                                fr?: string;
                                nb?: string;
                                nl?: string;
                                sv?: string;
                            };
                            /** @description The size of the photo the rect is measured in, when it is not the size of the image the url serves; absent, the image's own. */
                            photoSizePx?: {
                                /** @description Its height, in pixels. */
                                h: number;
                                /** @description Its width, in pixels. */
                                w: number;
                            };
                            /** @description Where the print sits in the photo, in the photo's pixels. */
                            placementRectPx: {
                                /** @description Its height, in the photo's pixels. */
                                h: number;
                                /** @description Its width, in the photo's pixels. */
                                w: number;
                                /** @description From the photo's left edge, in its pixels. */
                                x: number;
                                /** @description From the photo's top edge, in its pixels. */
                                y: number;
                            };
                            /** @description How strongly the photo's light and shade carry onto the design, from 0 (flat) to 1; absent, the default. */
                            shadingStrength?: number;
                            /**
                             * Format: uri
                             * @description The photo's address, http or https.
                             */
                            url: string;
                            /** @description The store's own name for the way the product is photographed: photos sharing one are one view. */
                            viewId?: string;
                            /** @description How the design wraps round the product in the photo, a mug or a bottle; absent or null, flat. */
                            warp?: {
                                /** @description How far round the product the rect reaches, above 0 and at most 1. */
                                curvature: number;
                                /** @description How dark the design turns toward the product's silhouette, 0 to 1. */
                                edgeFalloff?: number;
                                /**
                                 * @description The one kind of wrap: an upright round product.
                                 * @enum {string}
                                 */
                                kind: "cylinder";
                            } | null;
                        }[];
                        /** @description The blank's placement it is printed in; with blankId. */
                        placementId?: string;
                        /** @description The sizes the shopper picks from, for a print within its area. */
                        printSizes?: {
                            /** @description The print's height, in mm. */
                            heightMm: number;
                            /** @description What the menu calls the size. */
                            label: string;
                            /** @description The label per customer-facing language, by code: only the languages it has one in. A designer shown in a language left out reads `label`. */
                            localizedLabels?: {
                                da?: string;
                                de?: string;
                                en?: string;
                                es?: string;
                                fi?: string;
                                fr?: string;
                                nb?: string;
                                nl?: string;
                                sv?: string;
                            };
                            /** @description The print's width, in mm. */
                            widthMm: number;
                        }[];
                        /** @description The photo that starts selected, by its place in mockups. */
                        selectedMockupIndex?: number;
                        /** @description The size that starts selected, by its place in printSizes. */
                        selectedPrintSizeIndex?: number;
                        /** @description The template's base id; the link's own when absent. */
                        templateId?: string;
                        /** @description The size the side sells, as a value of each option its blank's print areas change with (`{"Size": "XL"}`): its proofs and designs are made at that size, and a request naming another is refused. Only on a blank whose print areas change with its size; absent, the shopper's request names the size. */
                        variantRow?: {
                            [key: string]: string;
                        };
                        /** @description The blank's variants offered, by ref; empty or absent, all. */
                        variants?: string[];
                        /** @description The blank's views the side is shown in; empty or absent, all. */
                        views?: string[];
                    }[];
                    /** @description What a designer link carries back to its `returnUrl`; null removes it. Setting one makes the link one shopper's visit again: it works for 24 hours from the change. */
                    state?: string | null;
                    /** @description A designer link's template, by base id: the one a link with one side opens, and a side naming none. Sent with what the page shows; absent, the link keeps its template. */
                    templateId?: string;
                    /** @description The size the side sells, as a value of each option its blank's print areas change with (`{"Size": "XL"}`): its proofs and designs are made at that size, and a request naming another is refused. Only on a blank whose print areas change with its size; absent, the shopper's request names the size. */
                    variantRow?: {
                        [key: string]: string;
                    };
                    /** @description The blank's variants offered, by ref; empty or absent, all. */
                    variants?: string[];
                    /** @description The blank's views the side is shown in; empty or absent, all. */
                    views?: string[];
                };
            };
        };
        responses: {
            /** @description The link as it now stands */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description The brand the link's page is drawn in; null for the workspace's default, whichever that is when it opens. */
                        brandId: string | null;
                        createdAt: number;
                        /** @description The member who handed it out; null when no member did. */
                        createdBy: {
                            name: string | null;
                            userId: string;
                        } | null;
                        /** @description The secret key or connected store that handed the link out. */
                        createdByKey: {
                            id: string;
                            /** @description `sk` for a secret key, `ik` for a connected store; null once the key is gone. */
                            kind: string | null;
                            /** @description The key's label, or the store's; null once the key is gone. */
                            name: string | null;
                        } | null;
                        /** @description How many designs a designer link may make; null for none. */
                        designLimit: {
                            /** @description How many designs the link may make in its period. */
                            count: number;
                            /** @description `total` counts every design the link made; `hour`, `day` and `week` the last 60 minutes, 24 hours or 7 days, rolling. */
                            period: string;
                            /** @description At the limit, when the link makes designs again; null below it, and for a total limit. */
                            reopensAt: number | null;
                            /** @description The designs the limit counts now: one per side approved, in the rolling window. */
                            used: number;
                        } | null;
                        /** @description How many designs a designer link made, one per side approved; null for any other kind. */
                        designs: number | null;
                        /** @description When the link stops working; null for one that never does. */
                        expiresAt: number | null;
                        id: string;
                        kind: string;
                        /** @description When its page last opened, to the hour; null for never. */
                        lastOpenedAt: number | null;
                        /** @description The language the link's page is shown in, which its `url` names as `?lang=<locale>`; null when it names none, and the page is shown in the workspace's default language. */
                        locale: string | null;
                        mayDecide: boolean;
                        /** @description The workspace's name for the link. */
                        name: string | null;
                        /** @description Whether a designer link's page draws the placement frame around the shopper's picture at rest; false for every other link. */
                        placementFrame: boolean;
                        /** @description Whether a designer link's page draws the print area's frame; false for every other link. */
                        printAreaFrame: boolean;
                        returnUrl: string | null;
                        /** @description Who handed it out: `member`; `key`, a secret key or connected store (`createdByKey`, null for a key the deployment configures); `auto`, sent with an order to a custom printshop. */
                        source: string;
                        /** @description What the link is about; null once it no longer exists. */
                        subject: {
                            /** @description The subject's name: a template's name; for a design, the name of its template; for an order, its external reference, null when it has none. */
                            label: string | null;
                            meta: {
                                /** @description The blank its sides are printed on; null for none. */
                                blank: {
                                    id: string;
                                    name: string | null;
                                } | null;
                                /** @description Whether the link carries one shopper's visit (`state`). */
                                carriesVisit: boolean;
                                /** @description The host its page sends a shopper back to; null for none. */
                                returnHost: string | null;
                                /** @description One entry per side, one for a link with one. */
                                sides: {
                                    key: string | null;
                                    label: string | null;
                                    /** @description The sizes its menu offers; empty for none. */
                                    printSizes: {
                                        heightMm: number;
                                        label: string;
                                        widthMm: number;
                                    }[];
                                }[];
                                /** @enum {string} */
                                type: "template";
                            } | {
                                status: string;
                                /** @enum {string} */
                                type: "design";
                            } | {
                                /** @description The printshop the order went to; null for none. */
                                printshop: {
                                    id: string;
                                    name: string;
                                } | null;
                                status: string;
                                /** @enum {string} */
                                type: "order";
                            };
                            /** @description What keeps the page from opening for now: `template_paused` (it opens again once the template is live), `printshop_disconnected`; null for nothing. */
                            warning: string | null;
                        } | null;
                        subjectId: string;
                        /** @description A designer link's address, which it keeps: it sits on a store's page until withdrawn. It carries `?lang=<locale>` when the link names a `locale`. Null for every other kind, whose address is shown once, and for a designer link made before addresses were kept until it is regenerated. */
                        url: string | null;
                    };
                };
            };
            /** @description Refused: design_limit_not_allowed, designer_settings_not_allowed, return_url_not_https, return_url_off_store, state_needs_return_url, expiry_fixed_by_state, invalid_input */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, feature_disabled */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found, subject_not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: share_link_name_taken, layout_out_of_date */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The link holding the name. Always sent with `share_link_name_taken`. */
                        holderId?: string | null;
                        /** @description Always sent with `layout_out_of_date`. */
                        reason?: string;
                    };
                };
            };
            /** @description Refused: share_link_name_too_long, unknown_placement, print_size_illegal, placement_unfilled, variant_row_invalid, unknown_layout, layout_wrong_ratio, linked_templates_differ, payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Sent with `payload_too_large`. */
                        bytes?: number;
                        error: string;
                        /** @description The size's place in the side's menu. Always sent with `print_size_illegal`. */
                        index?: number;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                        /** @description The longest name a link may have. Always sent with `share_link_name_too_long`. */
                        maxLength?: number;
                        /** @description Always sent with `placement_unfilled`. */
                        placement?: string;
                        /** @description With `print_size_illegal`: `too_large`: larger than the placement takes. `print_size_not_area`: smaller than a placement printed across its whole area. `wrong_ratio`: further from the template's shape than its tolerance allows. Always sent with `print_size_illegal`, `placement_unfilled`, `variant_row_invalid`, `layout_wrong_ratio`. With `print_size_illegal`: one of `too_large`, `print_size_not_area`, `wrong_ratio`. */
                        reason?: string;
                        /** @description The side's key; null on a link with one side. Always sent with `print_size_illegal`. */
                        side?: string | null;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "shareLinks.designer.get": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The link's settings */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description The blank it is printed on; with placementId, or a panelLayout. */
                        blankId?: string;
                        /** @description The brand the link's page is drawn in; null for the workspace's default, whichever that is when it opens. */
                        brandId: string | null;
                        /** @description How many designs a designer link may make; null for none. */
                        designLimit: {
                            /** @description How many designs the link may make in its period. */
                            count: number;
                            /** @description `total` counts every design the link made; `hour`, `day` and `week` the last 60 minutes, 24 hours or 7 days, rolling. */
                            period: string;
                        } | null;
                        /** @description When it stops working; null for until withdrawn. */
                        expiresAt: number | null;
                        /** @description The link's id. */
                        id: string;
                        /** @description The variant the side starts on, by ref: one of `variants` when it names any. */
                        initialVariant?: string;
                        /** @description The view shown first; absent, the side's first with a photo. */
                        initialView?: string;
                        /** @description How every side's form lays out its steps: `page`, every step on one page, or `steps`, one step at a time. Absent, each side's form follows its template's own `form.layout`, and is a page when the template names none. */
                        layout?: string;
                        /** @description Which of the sides' placements one design drives, such as a sweater's sleeves: a preset, or groups of the sides' placements, a group with a repeat of its own where it repeats apart from the link. The sides of one group print one template. Absent, the groups the blank suggests whose sides print one template; the link keeps the groups it was made with. */
                        linkedPlacements?: {
                            /** @description Whether the shopper may take a placement out of its group and design it on its own. Absent, no. */
                            designSeparately?: boolean;
                            /** @description Groups of your own in place of a preset, each a list of placements, or `{ placements, repeat }` for a group that repeats apart from the link. A mirror left out is the blank's suggestion, else none. */
                            groups?: ({
                                /** @description Whether the placement's print is mirrored left to right. */
                                mirror?: boolean;
                                /** @description The id of one of the blank's placements. */
                                placementId: string;
                            }[] | {
                                /** @description Placements one design drives, two at least. */
                                placements: {
                                    /** @description Whether the placement's print is mirrored left to right. */
                                    mirror?: boolean;
                                    /** @description The id of one of the blank's placements. */
                                    placementId: string;
                                }[];
                                /** @description How the group's design is laid as a repeat, in place of the link's `repeat`; null places it once beside a link that repeats. */
                                repeat: {
                                    /** @description The layouts the shopper may pick, one at least, each once. */
                                    modes: string[];
                                    /** @description Whether the shopper may pick another of `modes` and another size. Otherwise every design prints as `start`. */
                                    shopperMayChange: boolean;
                                    /** @description Whether the shopper may place the design once instead (`repeat: null`). Only with `shopperMayChange`. */
                                    shopperMayTurnOff: boolean;
                                    /** @description What the design starts as: a repeat in one of `modes`, or null for placed once, which needs `shopperMayTurnOff`. A request through the link that names no repeat is made with it. */
                                    start: {
                                        /** @description How the tiles are laid: `grid` lines them up, `brick` moves every other row along by half a tile, `halfDrop` moves every other column down by half a tile, and `scatter` strews them at random places, turns and sizes, arranged by `seed`. */
                                        mode: string;
                                        /** @description Which arrangement a `scatter` draws: another seed is another arrangement of the same tile. Read by `scatter` only. */
                                        seed: number;
                                        /** @description The tile's width in percent of the print area's width, above 0 and at most 100; the tile keeps the template's shape. A tile that would print under 10 mm on a side is drawn at 10 mm. */
                                        size: number;
                                    } | null;
                                } | null;
                            })[];
                            /** @description `each`: every placement is designed on its own. `suggested`: the groups the blank suggests, such as its sleeves. `all`: one design drives every placement. Absent with no `groups`, `suggested`. */
                            preset?: string;
                        };
                        /** @description The language the link's page is shown in, which its `url` names as `?lang=<locale>`; null when it names none, and the page is shown in the workspace's default language. */
                        locale: string | null;
                        /** @description The store's own product photos the design is shown on, in place of the blank's views. */
                        mockups?: {
                            /** @description How far the photo's folds move the design, above 0 and at most 1; absent or null, not at all. */
                            displacementStrength?: number | null;
                            /** @description What the menu calls the photo. */
                            label: string;
                            /** @description The label per customer-facing language, by code: only the languages it has one in. A designer shown in a language left out reads `label`. */
                            localizedLabels?: {
                                da?: string;
                                de?: string;
                                en?: string;
                                es?: string;
                                fi?: string;
                                fr?: string;
                                nb?: string;
                                nl?: string;
                                sv?: string;
                            };
                            /** @description The size of the photo the rect is measured in, when it is not the size of the image the url serves; absent, the image's own. */
                            photoSizePx?: {
                                /** @description Its height, in pixels. */
                                h: number;
                                /** @description Its width, in pixels. */
                                w: number;
                            };
                            /** @description Where the print sits in the photo, in the photo's pixels. */
                            placementRectPx: {
                                /** @description Its height, in the photo's pixels. */
                                h: number;
                                /** @description Its width, in the photo's pixels. */
                                w: number;
                                /** @description From the photo's left edge, in its pixels. */
                                x: number;
                                /** @description From the photo's top edge, in its pixels. */
                                y: number;
                            };
                            /** @description How strongly the photo's light and shade carry onto the design, from 0 (flat) to 1; absent, the default. */
                            shadingStrength?: number;
                            /**
                             * Format: uri
                             * @description The photo's address, http or https.
                             */
                            url: string;
                            /** @description The store's own name for the way the product is photographed: photos sharing one are one view. */
                            viewId?: string;
                            /** @description How the design wraps round the product in the photo, a mug or a bottle; absent or null, flat. */
                            warp?: {
                                /** @description How far round the product the rect reaches, above 0 and at most 1. */
                                curvature: number;
                                /** @description How dark the design turns toward the product's silhouette, 0 to 1. */
                                edgeFalloff?: number;
                                /** @description The one kind of wrap: an upright round product. */
                                kind: string;
                            } | null;
                        }[];
                        /** @description The workspace's name for the link. */
                        name: string | null;
                        /** @description The name of a panel layout of the link's `blankId`, in place of `placementId`: the page draws one design across the layout's canvas, and each placement it lays out gets its print cut from it, so art runs across the seams. Not with `sides` or `printSizes`. */
                        panelLayout?: string;
                        /** @description Whether a designer link's page draws the placement frame around the shopper's picture at rest; false for every other link. */
                        placementFrame: boolean;
                        /** @description The blank's placement it is printed in; with blankId. */
                        placementId?: string;
                        /** @description Whether a designer link's page draws the print area's frame; false for every other link. */
                        printAreaFrame: boolean;
                        /** @description The sizes the shopper picks from, for a print within its area. */
                        printSizes?: {
                            /** @description The print's height, in mm. */
                            heightMm: number;
                            /** @description What the menu calls the size. */
                            label: string;
                            /** @description The label per customer-facing language, by code: only the languages it has one in. A designer shown in a language left out reads `label`. */
                            localizedLabels?: {
                                da?: string;
                                de?: string;
                                en?: string;
                                es?: string;
                                fi?: string;
                                fr?: string;
                                nb?: string;
                                nl?: string;
                                sv?: string;
                            };
                            /** @description The print's width, in mm. */
                            widthMm: number;
                        }[];
                        /** @description Whether every side's design is laid as a repeat of its template, which layouts the shopper may pick, what it starts as, and whether they may change it or turn it off; a linked group with a repeat of its own takes that instead. Absent, each design is placed once and a request through the link naming a repeat is refused. Not with `panelLayout`. */
                        repeat?: {
                            /** @description The layouts the shopper may pick, one at least, each once. */
                            modes: string[];
                            /** @description Whether the shopper may pick another of `modes` and another size. Otherwise every design prints as `start`. */
                            shopperMayChange: boolean;
                            /** @description Whether the shopper may place the design once instead (`repeat: null`). Only with `shopperMayChange`. */
                            shopperMayTurnOff: boolean;
                            /** @description What the design starts as: a repeat in one of `modes`, or null for placed once, which needs `shopperMayTurnOff`. A request through the link that names no repeat is made with it. */
                            start: {
                                /** @description How the tiles are laid: `grid` lines them up, `brick` moves every other row along by half a tile, `halfDrop` moves every other column down by half a tile, and `scatter` strews them at random places, turns and sizes, arranged by `seed`. */
                                mode: string;
                                /** @description Which arrangement a `scatter` draws: another seed is another arrangement of the same tile. Read by `scatter` only. */
                                seed: number;
                                /** @description The tile's width in percent of the print area's width, above 0 and at most 100; the tile keeps the template's shape. A tile that would print under 10 mm on a side is drawn at 10 mm. */
                                size: number;
                            } | null;
                        };
                        /** @description Where its page sends the shopper back to; null for none. */
                        returnUrl: string | null;
                        /** @description The photo that starts selected, by its place in mockups. */
                        selectedMockupIndex?: number;
                        /** @description The size that starts selected, by its place in printSizes. */
                        selectedPrintSizeIndex?: number;
                        /** @description Several sides of one item, a front and a back, each its own template and placement, designed one after the other; then the one-side fields go on each side instead. */
                        sides?: {
                            /** @description The blank it is printed on; with placementId, or a panelLayout. */
                            blankId?: string;
                            /** @description The variant the side starts on, by ref: one of `variants` when it names any. */
                            initialVariant?: string;
                            /** @description The view shown first; absent, the side's first with a photo. */
                            initialView?: string;
                            /** @description The side's own short name, such as front: lowercase letters, digits, - and _, unique within the link. */
                            key: string;
                            /** @description What the side's step is called, such as Front. */
                            label: string;
                            /** @description The label per customer-facing language, by code: only the languages it has one in. A designer shown in a language left out reads `label`. */
                            localizedLabels?: {
                                da?: string;
                                de?: string;
                                en?: string;
                                es?: string;
                                fi?: string;
                                fr?: string;
                                nb?: string;
                                nl?: string;
                                sv?: string;
                            };
                            /** @description The store's own product photos the design is shown on, in place of the blank's views. */
                            mockups?: {
                                /** @description How far the photo's folds move the design, above 0 and at most 1; absent or null, not at all. */
                                displacementStrength?: number | null;
                                /** @description What the menu calls the photo. */
                                label: string;
                                /** @description The label per customer-facing language, by code: only the languages it has one in. A designer shown in a language left out reads `label`. */
                                localizedLabels?: {
                                    da?: string;
                                    de?: string;
                                    en?: string;
                                    es?: string;
                                    fi?: string;
                                    fr?: string;
                                    nb?: string;
                                    nl?: string;
                                    sv?: string;
                                };
                                /** @description The size of the photo the rect is measured in, when it is not the size of the image the url serves; absent, the image's own. */
                                photoSizePx?: {
                                    /** @description Its height, in pixels. */
                                    h: number;
                                    /** @description Its width, in pixels. */
                                    w: number;
                                };
                                /** @description Where the print sits in the photo, in the photo's pixels. */
                                placementRectPx: {
                                    /** @description Its height, in the photo's pixels. */
                                    h: number;
                                    /** @description Its width, in the photo's pixels. */
                                    w: number;
                                    /** @description From the photo's left edge, in its pixels. */
                                    x: number;
                                    /** @description From the photo's top edge, in its pixels. */
                                    y: number;
                                };
                                /** @description How strongly the photo's light and shade carry onto the design, from 0 (flat) to 1; absent, the default. */
                                shadingStrength?: number;
                                /**
                                 * Format: uri
                                 * @description The photo's address, http or https.
                                 */
                                url: string;
                                /** @description The store's own name for the way the product is photographed: photos sharing one are one view. */
                                viewId?: string;
                                /** @description How the design wraps round the product in the photo, a mug or a bottle; absent or null, flat. */
                                warp?: {
                                    /** @description How far round the product the rect reaches, above 0 and at most 1. */
                                    curvature: number;
                                    /** @description How dark the design turns toward the product's silhouette, 0 to 1. */
                                    edgeFalloff?: number;
                                    /** @description The one kind of wrap: an upright round product. */
                                    kind: string;
                                } | null;
                            }[];
                            /** @description The blank's placement it is printed in; with blankId. */
                            placementId?: string;
                            /** @description The sizes the shopper picks from, for a print within its area. */
                            printSizes?: {
                                /** @description The print's height, in mm. */
                                heightMm: number;
                                /** @description What the menu calls the size. */
                                label: string;
                                /** @description The label per customer-facing language, by code: only the languages it has one in. A designer shown in a language left out reads `label`. */
                                localizedLabels?: {
                                    da?: string;
                                    de?: string;
                                    en?: string;
                                    es?: string;
                                    fi?: string;
                                    fr?: string;
                                    nb?: string;
                                    nl?: string;
                                    sv?: string;
                                };
                                /** @description The print's width, in mm. */
                                widthMm: number;
                            }[];
                            /** @description The photo that starts selected, by its place in mockups. */
                            selectedMockupIndex?: number;
                            /** @description The size that starts selected, by its place in printSizes. */
                            selectedPrintSizeIndex?: number;
                            /** @description The template's base id; the link's own when absent. */
                            templateId?: string;
                            /** @description The size the side sells, as a value of each option its blank's print areas change with (`{"Size": "XL"}`): its proofs and designs are made at that size, and a request naming another is refused. Only on a blank whose print areas change with its size; absent, the shopper's request names the size. */
                            variantRow?: {
                                [key: string]: string;
                            };
                            /** @description The blank's variants offered, by ref; empty or absent, all. */
                            variants?: string[];
                            /** @description The blank's views the side is shown in; empty or absent, all. */
                            views?: string[];
                        }[];
                        /** @description What it carries back to `returnUrl`; null for none. */
                        state: string | null;
                        /** @description The template the link opens, by base id; a side naming none. */
                        templateId: string;
                        /** @description The size the side sells, as a value of each option its blank's print areas change with (`{"Size": "XL"}`): its proofs and designs are made at that size, and a request naming another is refused. Only on a blank whose print areas change with its size; absent, the shopper's request names the size. */
                        variantRow?: {
                            [key: string]: string;
                        };
                        /** @description The blank's variants offered, by ref; empty or absent, all. */
                        variants?: string[];
                        /** @description The blank's views the side is shown in; empty or absent, all. */
                        views?: string[];
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, feature_disabled */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "shareLinks.regenerate": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The link with its new token */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description The brand the link's page is drawn in; null for the workspace's default, whichever that is when it opens. */
                        brandId: string | null;
                        createdAt: number;
                        /** @description How many designs a designer link may make; null for none. */
                        designLimit: {
                            /** @description How many designs the link may make in its period. */
                            count: number;
                            /** @description `total` counts every design the link made; `hour`, `day` and `week` the last 60 minutes, 24 hours or 7 days, rolling. */
                            period: string;
                        } | null;
                        /** @description When the link stops working; null for one that never does. */
                        expiresAt: number | null;
                        id: string;
                        kind: string;
                        /** @description The language the link's page is shown in, which its `url` names as `?lang=<locale>`; null when it names none, and the page is shown in the workspace's default language. */
                        locale: string | null;
                        mayDecide: boolean;
                        /** @description The workspace's name for the link. */
                        name: string | null;
                        /** @description Whether a designer link's page draws the placement frame around the shopper's picture at rest; false for every other link. */
                        placementFrame: boolean;
                        /** @description Whether a designer link's page draws the print area's frame; false for every other link. */
                        printAreaFrame: boolean;
                        returnUrl: string | null;
                        subjectId: string;
                        /** @description The link's token. Shown in this response only. */
                        token: string;
                        /** @description The hosted page the link opens, with `?lang=<locale>` when the link names a `locale`. */
                        url: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, feature_disabled */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: address_kept */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "storage.get": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The tenant's storage use */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Every category, in a fixed order, an empty one reading 0. */
                        categories: {
                            bytes: number;
                            category: string;
                            fileCount: number;
                        }[];
                        fileCount: number;
                        quotaBytes: number;
                        usedBytes: number;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "templates.list": {
        parameters: {
            query?: {
                /** @description Which templates: `all`, `draft`, `live`, `paused`. Any other value is refused `invalid_status`. */
                status?: string;
                q?: string;
                /** @description The templates to read, each `baseId@version`, at most 200; repeat it for several. Answers those that are live, in the order named, and leaves out the rest. The only list a publishable key may read, and taken alone: no other filter or page beside it. */
                ids?: string | string[];
                /** @description The page, from 1. A key's list is always paged. */
                page?: number;
                /** @description How many templates a page holds, at most 200; 50 when only `page` is given. */
                pageSize?: number;
                /** @description A member's page: only the templates filed in this category; `none`, those filed in none. */
                category?: string;
                /** @description A member's page: only the templates carrying any of these tags. Repeat it for several. */
                tag?: string | string[];
                /** @description A member's page: `updated` (the default) the most recently updated first, `name` by name, `designs` the most designs first, which needs `designs:read`. */
                sort?: "updated" | "name" | "designs";
                /** @description A member's page: the rows ordered by their group (live, paused, draft; categories by name, none last; tags the most used first, none last), `sort` within each, each row naming its `group`. Under `tag` a template is listed under each of its tags. */
                groupBy?: "none" | "status" | "category" | "tag";
                /** @description A member's page: with no `page`, the page that holds this template, the first place it is listed; page 1 when the filter leaves it out. */
                pageOf?: string;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description A key's page of live templates, or those named by `ids`; a member's archive: the tenant's templates and what the whole archive counts, or with `page`, `pageSize` or `pageOf` one page of it, arranged, with its place in the whole and what its filters and groups count */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        items: {
                            baseId: string;
                            /** @description The field keys of the fields a customer is offered: a value set on one is shown by any template with a field of the same key. */
                            fieldKeys: string[];
                            /** @description The template id, `baseId@version`, a designer is opened on. */
                            id: string;
                            latestVersion: number;
                            name: string;
                            /** @description Whether the customer's form offers anything to fill in or place: false when every layer is fixed or in no group, so a customer designing on it can change nothing. A store warns a merchant who sells a template meant to be filled in as a fixed product, or one that offers nothing as personalised. */
                            offersProperties: boolean;
                            previewUrl: string;
                            ratio: {
                                /** @description The ratio's height part. Positive. */
                                h: number;
                                /** @description The ratio's width part. Positive. */
                                w: number;
                            };
                            ratioTolerance: number;
                        }[];
                        page: number;
                        pageSize: number;
                        total: number;
                    } | {
                        counts: {
                            categories: {
                                id: string;
                                name: string;
                                templateCount: number;
                            }[];
                            statuses: {
                                draft?: number;
                                live?: number;
                                paused?: number;
                            };
                            tags: {
                                tag: string;
                                templateCount: number;
                            }[];
                            uncategorised: number;
                        };
                        facets: {
                            categories: {
                                categoryId: string | null;
                                count: number;
                            }[];
                            statuses: {
                                all?: number;
                                draft?: number;
                                live?: number;
                                paused?: number;
                            };
                        };
                        groups?: {
                            count: number;
                            key: string | null;
                        }[];
                        matched: number;
                        page: number;
                        pageSize: number;
                        templates: {
                            baseId: string;
                            categoryId: string | null;
                            group?: string | null;
                            hasDraft: boolean;
                            latestVersion: number | null;
                            layerCount: number;
                            name: string;
                            /** @description Whether the live version's customer form offers anything to fill in or place: false when every layer is fixed or in no group. A store warns a merchant who sells a template meant to be filled in as a fixed product, or one that offers nothing as personalised. Null for a template never published. */
                            offersProperties: boolean | null;
                            /** @description A link to the preview of its latest published version that opens with no key, for an hour or two, as a key's list answers one. Null for a template never published. */
                            previewUrl: string | null;
                            /** @description The live version's declared shape, which every print size of it is judged against; null for a template never published. */
                            ratio: {
                                h: number;
                                w: number;
                            } | null;
                            /** @description How far from `ratio` a print size may stray, relative; `0` is that shape only. Null with `ratio`. */
                            ratioTolerance: number | null;
                            status: string;
                            tags: string[];
                            updatedAt: number;
                            versions: number[];
                        }[];
                        /** @description How many rows the list holds across every page; grouped by tag, a template once per tag. */
                        total: number;
                    } | {
                        counts: {
                            categories: {
                                id: string;
                                name: string;
                                templateCount: number;
                            }[];
                            statuses: {
                                draft?: number;
                                live?: number;
                                paused?: number;
                            };
                            tags: {
                                tag: string;
                                templateCount: number;
                            }[];
                            uncategorised: number;
                        };
                        templates: {
                            baseId: string;
                            categoryId: string | null;
                            hasDraft: boolean;
                            latestVersion: number | null;
                            layerCount: number;
                            name: string;
                            /** @description Whether the live version's customer form offers anything to fill in or place: false when every layer is fixed or in no group. A store warns a merchant who sells a template meant to be filled in as a fixed product, or one that offers nothing as personalised. Null for a template never published. */
                            offersProperties: boolean | null;
                            /** @description A link to the preview of its latest published version that opens with no key, for an hour or two, as a key's list answers one. Null for a template never published. */
                            previewUrl: string | null;
                            /** @description The live version's declared shape, which every print size of it is judged against; null for a template never published. */
                            ratio: {
                                h: number;
                                w: number;
                            } | null;
                            /** @description How far from `ratio` a print size may stray, relative; `0` is that shape only. Null with `ratio`. */
                            ratioTolerance: number | null;
                            status: string;
                            tags: string[];
                            updatedAt: number;
                            versions: number[];
                        }[];
                    };
                };
            };
            /** @description Refused: invalid_status */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: forbidden, origin_forbidden, feature_disabled, secret_key_required, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: invalid_query */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "templates.publish": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description Ink id to the `updatedAt` (epoch ms) of that ink as the author's editor resolved the template against it. The publish refuses with `ink_changed` when one has moved since. */
                    inkVersions?: {
                        [key: string]: number;
                    };
                    /** @description Palette id to the `updatedAt` (epoch ms) the editor resolved it at; `palette_changed` when one has moved. */
                    paletteVersions?: {
                        [key: string]: number;
                    };
                    /** @description Shape id to the `updatedAt` (epoch ms) the editor resolved it at; `shape_changed` when one has moved. */
                    shapeVersions?: {
                        [key: string]: number;
                    };
                    template: components["schemas"]["TemplateInput"];
                } & {
                    [key: string]: unknown;
                };
            };
        };
        responses: {
            /** @description The version was published */
            201: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        templateId: string;
                    };
                };
            };
            /** @description Refused: template_required */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: plan_limit_reached, origin_forbidden, secret_key_required, feature_disabled, forbidden, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                        /** @description The limit the tenant is at: `templates`, `connectedStores`, `apiKeys`, `shareLinks`, `customDomains`, `printsMadePerMonth` (prints made without an order this month), `members`, `orders` (this month's orders, which getting a print's files without an order counts as), or a sandbox's own caps: `sandboxPrintsPerDay`, `sandboxPrintsPerMonth`, `sandboxOrdersPerMonth`. A sandbox shares every other limit with its live workspace. Always sent with `plan_limit_reached`. */
                        limit?: string;
                        /** @description How many the plan allows. Always sent with `plan_limit_reached`. */
                        max?: number;
                        /** @description The plan whose limit it is. Always sent with `plan_limit_reached`. */
                        plan?: string;
                    };
                };
            };
            /** @description Refused: ink_changed, shape_changed, palette_changed, font_changed, version_exists, base_id_deleted, showcases_changed */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: invalid_template, invalid_publish, payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Sent with `payload_too_large`. */
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                        /** @description Always sent with `invalid_template`, `invalid_publish`. */
                        reason?: string;
                        /** @description Sent with `invalid_template`. */
                        violations?: {
                            /** @description On a `text_draws_fallback_glyphs` or `text_draws_missing_glyphs` warning: the characters the text's font cannot draw, each once, in the order the text first holds them. Absent on every other violation. */
                            characters?: string[];
                            given: unknown;
                            /** @description The language whose overrides break the rule, when only the template as it reads in that language does. Absent, the original. */
                            language?: string;
                            layerId: string;
                            prop: string;
                            rule: string;
                            /** @description `error` refuses a publish; `warning` is worth the author's attention and never does. */
                            severity: string;
                        }[];
                    };
                };
            };
            /** @description Refused: template_renderer_failed, publish_gate_failed, db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
            /** @description Refused: print_box_unavailable, publish_references_unavailable, lock_timeout */
            503: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
        };
    };
    "templates.get": {
        parameters: {
            query?: {
                /** @description The IANA timezone the template's dynamic values are resolved in, such as `Europe/Stockholm`: today's date there. Absent, the workspace's timezone. */
                tz?: string;
                /** @description The language the template's dynamic values are written in when their name names none, one of `en`, `sv`, `de`, `fr`, `es`, `nl`, `da`, `nb`, `fi`. Absent, the workspace's default language. A value whose name carries a language, `{date.long:sv}`, keeps it. */
                lang?: "en" | "sv" | "de" | "fr" | "es" | "nl" | "da" | "nb" | "fi";
            };
            header?: {
                /** @description The SDK release making the request, which the SDK sends itself. A release that cannot draw the template is refused `sdk_outdated`; a request naming none is served. */
                "x-pixonaut-sdk-version"?: string;
            };
            path: {
                /** @description A template id, `baseId@version`. */
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The template and its form */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description By palette name as `template.palettes` holds it, each colour's name in `lang` by its own name: what the designer shows under its swatch and lists as the field's value. Only the colours named in it; the rest read their own name, which a pick is held as in every language. */
                        colourNames?: {
                            [key: string]: {
                                [key: string]: string;
                            };
                        };
                        dieShapeId?: string;
                        /** @description The field keys of the fields a customer is offered: a value set on one is shown by any template with a field of the same key. */
                        fieldKeys: string[];
                        /** @description Each fixed text naming a field, such as `Happy birthday {field.name}`, by layer id, as runs: the template's text holds each field's default, and a designer writes the customer's value for each field into its runs, joining them as they are, never reading the result again. Absent when no text names a field. */
                        fieldTexts?: {
                            [key: string]: ({
                                literal: string;
                            } | {
                                /** @description Written in the field's place when its value is empty. */
                                fallback?: string;
                                field: string;
                            })[];
                        };
                        formSchema: {
                            layout?: string;
                            steps: {
                                fields: {
                                    constraints: {
                                        [key: string]: unknown;
                                    };
                                    default?: unknown;
                                    description?: string;
                                    label: string;
                                    layerId: string;
                                    prop: string;
                                    type: string;
                                }[];
                                groupId: string;
                                index: number | null;
                                label: string;
                                layerIds: string[];
                                transforms: {
                                    layerId: string;
                                    transform: {
                                        [key: string]: unknown;
                                    };
                                }[];
                            }[];
                        };
                        /** @description The language the template is read in, one of `en`, `sv`, `de`, `fr`, `es`, `nl`, `da`, `nb`, `fi`: `lang`, else the workspace's default. `template` is the original with that language's overrides (`localized`) merged in. */
                        language: string;
                        layerShapeIds?: {
                            [key: string]: string;
                        };
                        offeredShapes?: {
                            [key: string]: unknown;
                        };
                        /** @description Whether the customer's form offers anything to fill in or place: false when every layer is fixed or in no group, so a customer designing on it can change nothing. A store warns a merchant who sells a template meant to be filled in as a fixed product, or one that offers nothing as personalised. */
                        offersProperties: boolean;
                        optionLabels?: {
                            [key: string]: string;
                        };
                        /** @description Whether the designer offers the customer Pixel (`POST /v1/pixel/designer`): the template has Pixel for customers on and the workspace has not turned it off. A round may still be refused, as that route says. */
                        pixel: boolean;
                        poweredBy: boolean;
                        previewUrl: string;
                        printFloorDpi: number;
                        printMargins: {
                            bleedMm: number;
                            safeAreaMm: number;
                        };
                        /** @description The template's showcases, by id and name: sets of example values its preview and mockup images are drawn with when their `showcase` names one, each with a link to its preview. Empty when it holds none. Their values are not served: the designer, a design, a proof and a print are drawn from `template` alone. */
                        showcases: {
                            id: string;
                            name: string;
                            /** @description A link to the preview drawn with this set, opening with no key for an hour or two, as `previewUrl` does the defaults'. */
                            previewUrl: string;
                        }[];
                        status: string;
                        template: components["schemas"]["ResolvedTemplate"];
                        /** @description The template's workspace's default language, one of `en`, `sv`, `de`, `fr`, `es`, `nl`, `da`, `nb`, `fi`: what the SDK designer is shown in when its mount names no `locale`. */
                        workspaceLanguage: string;
                    };
                };
            };
            /** @description Refused: sdk_version_invalid, invalid_query */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `invalid_query`. */
                        reason?: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, feature_disabled, forbidden, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description No published template has this id */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Refused: sdk_outdated */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /**
                         * @description The first SDK release after the caller's that can draw the template, or null when no released SDK can yet. Always sent with `sdk_outdated`.
                         * @example 0.15.0
                         */
                        minimumSdkVersion?: string | null;
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "templates.constraints.get": {
        parameters: {
            query?: {
                blankId?: string;
                placementId?: string;
            };
            header?: never;
            path: {
                /** @description A template id, `baseId@version`. */
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The template's print-size constraints */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        fit?: string;
                        placement?: {
                            blankId: string;
                            bleedMm: number;
                            /** @description The bundled output profile whose tables draw a design on the placement on screen, or, where `cmykPreviewTables` is said, draw it when those cannot be read. */
                            cmykPreviewProfile: string;
                            /** @description Where the tables a design on the placement is drawn through are read, when its print goes through an output profile the workspace uploaded and they are made: a path on the api, read with the same key. */
                            cmykPreviewTables?: string;
                            /** @description `full` when a print covers the placement's whole area: the size rule then refuses one smaller than `maxWidthMm` × `maxHeightMm` (`print_size_not_area`). `within` when it is placed inside it. */
                            coverage: string;
                            defaultHeightMm: number;
                            defaultWidthMm: number;
                            maxHeightMm: number;
                            maxWidthMm: number;
                            placementId: string;
                            printHeightMm: number;
                            printWidthMm: number;
                            safeAreaMm: number;
                            /** @description Where on the product a print may go, when not the whole rectangle: the outline, then each cut-out, in fractions of the print box, filled even-odd. A live preview clips the design to it and draws it as a guide, as the proof and the print file are cut to it. */
                            shape?: {
                                /** @description True when the print shop cuts the product to this shape: the outline and the cut-outs go into the print file as its cut line. Omitted, the product already has the shape. */
                                cutByPrintShop?: boolean;
                                /** @description The shape as SVG path data in fractions of the print area, 0 to 1 across and down (curves, no arcs): its first subpath the outline, every further one a cut-out, filled even-odd, each subpath closed. */
                                dFrac: string;
                            };
                            /** @description The blank's sizes the template can and can't print at, on a placement whose print area changes with an option (coverage `full`, or a position that prints one size only). Both empty on a placement whose area doesn't, which the template fits at every size. */
                            sizes: {
                                /** @description The sizes the template prints at here, by option value, such as `S`; several options' values are joined with ` / `. */
                                fits: string[];
                                /** @description The sizes the template can't print at here: a design at one is refused when committed. */
                                misfits: string[];
                            };
                        };
                        ratio: {
                            /** @description The ratio's height part. Positive. */
                            h: number;
                            /** @description The ratio's width part. Positive. */
                            w: number;
                        };
                        ratioTolerance: number;
                        templateId: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, feature_disabled, forbidden, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: invalid_query, unknown_placement */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
            /** @description Refused: print_box_unavailable */
            503: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
        };
    };
    "templates.designerLinks.create": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                /** @description The template's base id: the link follows whatever version is live. */
                id: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description The blank it is printed on; with placementId, or a panelLayout. */
                    blankId?: string;
                    /** @description The brand the link's page is drawn in: its name, logo and accent colour (`GET /v1/brands`). Refused `brand_not_found` unless it is one of the workspace's. Absent, a link a connected store's key hands out keeps the store's brand, and any other is drawn in whichever brand is the workspace's default when it opens. A brand a link that still opens names cannot be deleted. */
                    brandId?: string;
                    /** @description How many designs the link's page may make, in total or per rolling hour, day or week. Each side approved counts one. At the limit the page, and an approval, answer `429 link_design_limit`. Absent, no limit. */
                    designLimit?: {
                        /** @description How many designs the link may make in its period. */
                        count: number;
                        /**
                         * @description `total` counts every design the link made; `hour`, `day` and `week` the last 60 minutes, 24 hours or 7 days, rolling.
                         * @enum {string}
                         */
                        period: "total" | "hour" | "day" | "week";
                    };
                    /** @description How long the link works, in days, up to 365. Absent, it works until withdrawn. Not with `state`, which names one shopper's visit and fixes the link's lifetime at 24 hours. */
                    expiresInDays?: number;
                    /** @description The variant the side starts on, by ref: one of `variants` when it names any. */
                    initialVariant?: string;
                    /** @description The view shown first; absent, the side's first with a photo. */
                    initialView?: string;
                    /**
                     * @description How every side's form lays out its steps: `page`, every step on one page, or `steps`, one step at a time. Absent, each side's form follows its template's own `form.layout`, and is a page when the template names none.
                     * @enum {string}
                     */
                    layout?: "page" | "steps";
                    /** @description Which of the sides' placements one design drives, such as a sweater's sleeves: a preset, or groups of the sides' placements, a group with a repeat of its own where it repeats apart from the link. The sides of one group print one template. Absent, the groups the blank suggests whose sides print one template; the link keeps the groups it was made with. */
                    linkedPlacements?: {
                        /** @description Whether the shopper may take a placement out of its group and design it on its own. Absent, no. */
                        designSeparately?: boolean;
                        /** @description Groups of your own in place of a preset, each a list of placements, or `{ placements, repeat }` for a group that repeats apart from the link. A mirror left out is the blank's suggestion, else none. */
                        groups?: ({
                            /** @description Whether the placement's print is mirrored left to right. */
                            mirror?: boolean;
                            /** @description The id of one of the blank's placements. */
                            placementId: string;
                        }[] | {
                            /** @description Placements one design drives, two at least. */
                            placements: {
                                /** @description Whether the placement's print is mirrored left to right. */
                                mirror?: boolean;
                                /** @description The id of one of the blank's placements. */
                                placementId: string;
                            }[];
                            /** @description How the group's design is laid as a repeat, in place of the link's `repeat`; null places it once beside a link that repeats. */
                            repeat: {
                                /** @description The layouts the shopper may pick, one at least, each once. */
                                modes: ("grid" | "brick" | "halfDrop" | "scatter")[];
                                /** @description Whether the shopper may pick another of `modes` and another size. Otherwise every design prints as `start`. */
                                shopperMayChange: boolean;
                                /** @description Whether the shopper may place the design once instead (`repeat: null`). Only with `shopperMayChange`. */
                                shopperMayTurnOff: boolean;
                                /** @description What the design starts as: a repeat in one of `modes`, or null for placed once, which needs `shopperMayTurnOff`. A request through the link that names no repeat is made with it. */
                                start: {
                                    /**
                                     * @description How the tiles are laid: `grid` lines them up, `brick` moves every other row along by half a tile, `halfDrop` moves every other column down by half a tile, and `scatter` strews them at random places, turns and sizes, arranged by `seed`.
                                     * @enum {string}
                                     */
                                    mode: "grid" | "brick" | "halfDrop" | "scatter";
                                    /** @description Which arrangement a `scatter` draws: another seed is another arrangement of the same tile. Read by `scatter` only. */
                                    seed: number;
                                    /** @description The tile's width in percent of the print area's width, above 0 and at most 100; the tile keeps the template's shape. A tile that would print under 10 mm on a side is drawn at 10 mm. */
                                    size: number;
                                } | null;
                            } | null;
                        })[];
                        /**
                         * @description `each`: every placement is designed on its own. `suggested`: the groups the blank suggests, such as its sleeves. `all`: one design drives every placement. Absent with no `groups`, `suggested`.
                         * @enum {string}
                         */
                        preset?: "each" | "suggested" | "all";
                    };
                    /**
                     * @description The language the page is shown in: one of `en`, `sv`, `de`, `fr`, `es`, `nl`, `da`, `nb`, `fi`. Absent, the page is shown in the workspace's default language. The link's `url` carries `?lang=<locale>` when it names one.
                     * @enum {string}
                     */
                    locale?: "en" | "sv" | "de" | "fr" | "es" | "nl" | "da" | "nb" | "fi";
                    /** @description The store's own product photos the design is shown on, in place of the blank's views. */
                    mockups?: {
                        /** @description How far the photo's folds move the design, above 0 and at most 1; absent or null, not at all. */
                        displacementStrength?: number | null;
                        /** @description What the menu calls the photo. */
                        label: string;
                        /** @description The label per customer-facing language, by code: only the languages it has one in. A designer shown in a language left out reads `label`. */
                        localizedLabels?: {
                            da?: string;
                            de?: string;
                            en?: string;
                            es?: string;
                            fi?: string;
                            fr?: string;
                            nb?: string;
                            nl?: string;
                            sv?: string;
                        };
                        /** @description The size of the photo the rect is measured in, when it is not the size of the image the url serves; absent, the image's own. */
                        photoSizePx?: {
                            /** @description Its height, in pixels. */
                            h: number;
                            /** @description Its width, in pixels. */
                            w: number;
                        };
                        /** @description Where the print sits in the photo, in the photo's pixels. */
                        placementRectPx: {
                            /** @description Its height, in the photo's pixels. */
                            h: number;
                            /** @description Its width, in the photo's pixels. */
                            w: number;
                            /** @description From the photo's left edge, in its pixels. */
                            x: number;
                            /** @description From the photo's top edge, in its pixels. */
                            y: number;
                        };
                        /** @description How strongly the photo's light and shade carry onto the design, from 0 (flat) to 1; absent, the default. */
                        shadingStrength?: number;
                        /**
                         * Format: uri
                         * @description The photo's address, http or https.
                         */
                        url: string;
                        /** @description The store's own name for the way the product is photographed: photos sharing one are one view. */
                        viewId?: string;
                        /** @description How the design wraps round the product in the photo, a mug or a bottle; absent or null, flat. */
                        warp?: {
                            /** @description How far round the product the rect reaches, above 0 and at most 1. */
                            curvature: number;
                            /** @description How dark the design turns toward the product's silhouette, 0 to 1. */
                            edgeFalloff?: number;
                            /**
                             * @description The one kind of wrap: an upright round product.
                             * @enum {string}
                             */
                            kind: "cylinder";
                        } | null;
                    }[];
                    /** @description The workspace's own name for the link (`Spring market stand`), at most 80 characters, never shown on its page. Trimmed, inner spaces made one; empty is no name. Unique among the workspace's working links, case aside: one another holds is refused `share_link_name_taken` naming the holder, a longer one `share_link_name_too_long`. A withdrawn or expired link frees its name. */
                    name?: string;
                    /** @description The name of a panel layout of the link's `blankId`, in place of `placementId`: the page draws one design across the layout's canvas, and each placement it lays out gets its print cut from it, so art runs across the seams. Not with `sides` or `printSizes`. */
                    panelLayout?: string;
                    /** @description Whether the link's page draws the placement frame, the ring and corner handles around the shopper's picture, at rest, as the SDK's `showPlacementFrame` does. Absent, the frame shows only while the picture is dragged or sized on the preview. */
                    placementFrame?: boolean;
                    /** @description The blank's placement it is printed in; with blankId. */
                    placementId?: string;
                    /** @description Whether the link's page draws a thin frame around the print area on the product photo, as the SDK's `showPrintAreaFrame` does. Absent, no frame. */
                    printAreaFrame?: boolean;
                    /** @description The sizes the shopper picks from, for a print within its area. */
                    printSizes?: {
                        /** @description The print's height, in mm. */
                        heightMm: number;
                        /** @description What the menu calls the size. */
                        label: string;
                        /** @description The label per customer-facing language, by code: only the languages it has one in. A designer shown in a language left out reads `label`. */
                        localizedLabels?: {
                            da?: string;
                            de?: string;
                            en?: string;
                            es?: string;
                            fi?: string;
                            fr?: string;
                            nb?: string;
                            nl?: string;
                            sv?: string;
                        };
                        /** @description The print's width, in mm. */
                        widthMm: number;
                    }[];
                    /** @description Whether every side's design is laid as a repeat of its template, which layouts the shopper may pick, what it starts as, and whether they may change it or turn it off; a linked group with a repeat of its own takes that instead. Absent, each design is placed once and a request through the link naming a repeat is refused. Not with `panelLayout`. */
                    repeat?: {
                        /** @description The layouts the shopper may pick, one at least, each once. */
                        modes: ("grid" | "brick" | "halfDrop" | "scatter")[];
                        /** @description Whether the shopper may pick another of `modes` and another size. Otherwise every design prints as `start`. */
                        shopperMayChange: boolean;
                        /** @description Whether the shopper may place the design once instead (`repeat: null`). Only with `shopperMayChange`. */
                        shopperMayTurnOff: boolean;
                        /** @description What the design starts as: a repeat in one of `modes`, or null for placed once, which needs `shopperMayTurnOff`. A request through the link that names no repeat is made with it. */
                        start: {
                            /**
                             * @description How the tiles are laid: `grid` lines them up, `brick` moves every other row along by half a tile, `halfDrop` moves every other column down by half a tile, and `scatter` strews them at random places, turns and sizes, arranged by `seed`.
                             * @enum {string}
                             */
                            mode: "grid" | "brick" | "halfDrop" | "scatter";
                            /** @description Which arrangement a `scatter` draws: another seed is another arrangement of the same tile. Read by `scatter` only. */
                            seed: number;
                            /** @description The tile's width in percent of the print area's width, above 0 and at most 100; the tile keeps the template's shape. A tile that would print under 10 mm on a side is drawn at 10 mm. */
                            size: number;
                        } | null;
                    };
                    /** @description Where the hosted designer sends the shopper back to: with `state` and the approved proof's `proofToken`, which the store commits with its key, or with `state` alone when they cancel. A link with `sides` returns each side's proof under its key, `proofToken[<key>]`, and only once every side is approved. Without it, the page commits the design of every side itself and shows their ids. On one of the origins the tenant's publishable keys are allowed on. */
                    returnUrl?: string;
                    /** @description The photo that starts selected, by its place in mockups. */
                    selectedMockupIndex?: number;
                    /** @description The size that starts selected, by its place in printSizes. */
                    selectedPrintSizeIndex?: number;
                    /** @description Several sides of one item, a front and a back, each its own template and placement, designed one after the other; then the one-side fields go on each side instead. */
                    sides?: {
                        /** @description The blank it is printed on; with placementId, or a panelLayout. */
                        blankId?: string;
                        /** @description The variant the side starts on, by ref: one of `variants` when it names any. */
                        initialVariant?: string;
                        /** @description The view shown first; absent, the side's first with a photo. */
                        initialView?: string;
                        /** @description The side's own short name, such as front: lowercase letters, digits, - and _, unique within the link. */
                        key: string;
                        /** @description What the side's step is called, such as Front. */
                        label: string;
                        /** @description The label per customer-facing language, by code: only the languages it has one in. A designer shown in a language left out reads `label`. */
                        localizedLabels?: {
                            da?: string;
                            de?: string;
                            en?: string;
                            es?: string;
                            fi?: string;
                            fr?: string;
                            nb?: string;
                            nl?: string;
                            sv?: string;
                        };
                        /** @description The store's own product photos the design is shown on, in place of the blank's views. */
                        mockups?: {
                            /** @description How far the photo's folds move the design, above 0 and at most 1; absent or null, not at all. */
                            displacementStrength?: number | null;
                            /** @description What the menu calls the photo. */
                            label: string;
                            /** @description The label per customer-facing language, by code: only the languages it has one in. A designer shown in a language left out reads `label`. */
                            localizedLabels?: {
                                da?: string;
                                de?: string;
                                en?: string;
                                es?: string;
                                fi?: string;
                                fr?: string;
                                nb?: string;
                                nl?: string;
                                sv?: string;
                            };
                            /** @description The size of the photo the rect is measured in, when it is not the size of the image the url serves; absent, the image's own. */
                            photoSizePx?: {
                                /** @description Its height, in pixels. */
                                h: number;
                                /** @description Its width, in pixels. */
                                w: number;
                            };
                            /** @description Where the print sits in the photo, in the photo's pixels. */
                            placementRectPx: {
                                /** @description Its height, in the photo's pixels. */
                                h: number;
                                /** @description Its width, in the photo's pixels. */
                                w: number;
                                /** @description From the photo's left edge, in its pixels. */
                                x: number;
                                /** @description From the photo's top edge, in its pixels. */
                                y: number;
                            };
                            /** @description How strongly the photo's light and shade carry onto the design, from 0 (flat) to 1; absent, the default. */
                            shadingStrength?: number;
                            /**
                             * Format: uri
                             * @description The photo's address, http or https.
                             */
                            url: string;
                            /** @description The store's own name for the way the product is photographed: photos sharing one are one view. */
                            viewId?: string;
                            /** @description How the design wraps round the product in the photo, a mug or a bottle; absent or null, flat. */
                            warp?: {
                                /** @description How far round the product the rect reaches, above 0 and at most 1. */
                                curvature: number;
                                /** @description How dark the design turns toward the product's silhouette, 0 to 1. */
                                edgeFalloff?: number;
                                /**
                                 * @description The one kind of wrap: an upright round product.
                                 * @enum {string}
                                 */
                                kind: "cylinder";
                            } | null;
                        }[];
                        /** @description The blank's placement it is printed in; with blankId. */
                        placementId?: string;
                        /** @description The sizes the shopper picks from, for a print within its area. */
                        printSizes?: {
                            /** @description The print's height, in mm. */
                            heightMm: number;
                            /** @description What the menu calls the size. */
                            label: string;
                            /** @description The label per customer-facing language, by code: only the languages it has one in. A designer shown in a language left out reads `label`. */
                            localizedLabels?: {
                                da?: string;
                                de?: string;
                                en?: string;
                                es?: string;
                                fi?: string;
                                fr?: string;
                                nb?: string;
                                nl?: string;
                                sv?: string;
                            };
                            /** @description The print's width, in mm. */
                            widthMm: number;
                        }[];
                        /** @description The photo that starts selected, by its place in mockups. */
                        selectedMockupIndex?: number;
                        /** @description The size that starts selected, by its place in printSizes. */
                        selectedPrintSizeIndex?: number;
                        /** @description The template's base id; the link's own when absent. */
                        templateId?: string;
                        /** @description The size the side sells, as a value of each option its blank's print areas change with (`{"Size": "XL"}`): its proofs and designs are made at that size, and a request naming another is refused. Only on a blank whose print areas change with its size; absent, the shopper's request names the size. */
                        variantRow?: {
                            [key: string]: string;
                        };
                        /** @description The blank's variants offered, by ref; empty or absent, all. */
                        variants?: string[];
                        /** @description The blank's views the side is shown in; empty or absent, all. */
                        views?: string[];
                    }[];
                    /** @description Carried back to `returnUrl` untouched, for the store to match the customer to its own session. Only with `returnUrl`. */
                    state?: string;
                    /** @description The size the side sells, as a value of each option its blank's print areas change with (`{"Size": "XL"}`): its proofs and designs are made at that size, and a request naming another is refused. Only on a blank whose print areas change with its size; absent, the shopper's request names the size. */
                    variantRow?: {
                        [key: string]: string;
                    };
                    /** @description The blank's variants offered, by ref; empty or absent, all. */
                    variants?: string[];
                    /** @description The blank's views the side is shown in; empty or absent, all. */
                    views?: string[];
                };
            };
        };
        responses: {
            /** @description The new link */
            201: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description The brand the link's page is drawn in; null for the workspace's default, whichever that is when it opens. */
                        brandId: string | null;
                        /** @description How many designs a designer link may make; null for none. */
                        designLimit: {
                            /** @description How many designs the link may make in its period. */
                            count: number;
                            /** @description `total` counts every design the link made; `hour`, `day` and `week` the last 60 minutes, 24 hours or 7 days, rolling. */
                            period: string;
                        } | null;
                        /** @description When the link stops working: 24 hours after it was handed out for a link carrying `state`, `expiresInDays` days after for one that names them, and null for one that names neither, which works until withdrawn. */
                        expiresAt: number | null;
                        /** @description The link's id, as the share-link list names it. */
                        id: string;
                        /** @description The language the link's page is shown in, which its `url` names as `?lang=<locale>`; null when it names none, and the page is shown in the workspace's default language. */
                        locale: string | null;
                        /** @description The workspace's name for the link. */
                        name: string | null;
                        /** @description Whether a designer link's page draws the placement frame around the shopper's picture at rest; false for every other link. */
                        placementFrame: boolean;
                        /** @description Whether a designer link's page draws the print area's frame; false for every other link. */
                        printAreaFrame: boolean;
                        /** @description The link's token. Shown in this response only. */
                        token: string;
                        /** @description The hosted designer the link opens, with `?lang=<locale>` when the link names a `locale`. */
                        url: string;
                        /** @description What the link was made with that it is not built for, for whoever builds it; the shopper is shown none. `sides_over_recommended`: the link holds more than 4 sides. Each side is one more step on the hosted page, one more designer, canvas and photo set in the shopper's browser, and one more `proofToken[<key>]` on the return address. Absent when there is nothing to warn of. */
                        warnings?: {
                            code: string;
                            /** @description The most sides a designer is built for. */
                            recommended: number;
                            /** @description How many sides the link holds. */
                            sides: number;
                        }[];
                    };
                };
            };
            /** @description Refused: return_url_not_https, return_url_off_store, invalid_input */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `invalid_input`. */
                        reason?: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: plan_limit_reached, origin_forbidden, feature_disabled */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                        /** @description The limit the tenant is at: `templates`, `connectedStores`, `apiKeys`, `shareLinks`, `customDomains`, `printsMadePerMonth` (prints made without an order this month), `members`, `orders` (this month's orders, which getting a print's files without an order counts as), or a sandbox's own caps: `sandboxPrintsPerDay`, `sandboxPrintsPerMonth`, `sandboxOrdersPerMonth`. A sandbox shares every other limit with its live workspace. Always sent with `plan_limit_reached`. */
                        limit?: string;
                        /** @description How many the plan allows. Always sent with `plan_limit_reached`. */
                        max?: number;
                        /** @description The plan whose limit it is. Always sent with `plan_limit_reached`. */
                        plan?: string;
                    };
                };
            };
            /** @description Refused: subject_not_found, brand_not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: share_link_name_taken, layout_out_of_date */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The link holding the name. Always sent with `share_link_name_taken`. */
                        holderId?: string | null;
                        /** @description Always sent with `layout_out_of_date`. */
                        reason?: string;
                    };
                };
            };
            /** @description Refused: unknown_placement, print_size_illegal, placement_unfilled, variant_row_invalid, unknown_layout, layout_wrong_ratio, linked_templates_differ, share_link_name_too_long, payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Sent with `payload_too_large`. */
                        bytes?: number;
                        error: string;
                        /** @description The size's place in the side's menu. Always sent with `print_size_illegal`. */
                        index?: number;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                        /** @description The longest name a link may have. Always sent with `share_link_name_too_long`. */
                        maxLength?: number;
                        /** @description Always sent with `placement_unfilled`. */
                        placement?: string;
                        /** @description With `print_size_illegal`: `too_large`: larger than the placement takes. `print_size_not_area`: smaller than a placement printed across its whole area. `wrong_ratio`: further from the template's shape than its tolerance allows. Always sent with `print_size_illegal`, `placement_unfilled`, `variant_row_invalid`, `layout_wrong_ratio`. With `print_size_illegal`: one of `too_large`, `print_size_not_area`, `wrong_ratio`. */
                        reason?: string;
                        /** @description The side's key; null on a link with one side. Always sent with `print_size_illegal`. */
                        side?: string | null;
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
            /** @description Refused: lock_timeout */
            503: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
        };
    };
    "templates.fittingPlacements.list": {
        parameters: {
            query?: {
                /** @description The page to read, from 1; the first when left out. */
                page?: number;
                pageSize?: number;
                q?: string;
            };
            header?: never;
            path: {
                /** @description A template id, `baseId@version`. */
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description A page of placements with their verdicts */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        items: {
                            blankId: string;
                            blankName: string;
                            defaultHeightMm: number;
                            defaultWidthMm: number;
                            maxHeightMm: number;
                            maxWidthMm: number;
                            placementId: string;
                            placementName: string;
                            printHeightMm: number;
                            printWidthMm: number;
                            verdict: {
                                /** @enum {boolean} */
                                legal: true;
                            } | {
                                /** @enum {boolean} */
                                legal: false;
                                reason: string;
                            };
                        }[];
                        page: number;
                        pageSize: number;
                        total: number;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: invalid_query */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "templates.printSize.validate": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                /** @description A template id, `baseId@version`. */
                id: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    blankId?: string;
                    heightMm: number;
                    placementId?: string;
                    widthMm: number;
                } | {
                    blankId?: string;
                    placementId?: string;
                    sizes: {
                        heightMm: number;
                        widthMm: number;
                    }[];
                };
            };
        };
        responses: {
            /** @description The verdict, or one per size in the order asked */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @enum {boolean} */
                        legal: true;
                    } | {
                        /** @enum {boolean} */
                        legal: false;
                        reason: string;
                    } | {
                        verdicts: ({
                            /** @enum {boolean} */
                            legal: true;
                        } | {
                            /** @enum {boolean} */
                            legal: false;
                            reason: string;
                        })[];
                    };
                };
            };
            /** @description Refused: bad_json */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: forbidden, origin_forbidden, feature_disabled, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: invalid_body, unknown_placement, payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Sent with `payload_too_large`. */
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                        /** @description Always sent with `invalid_body`. */
                        reason?: string;
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "payloads.validate": {
        parameters: {
            query?: {
                /** @description The IANA timezone the template's dynamic values are resolved in, such as `Europe/Stockholm`: today's date there. Absent, the workspace's timezone. */
                tz?: string;
                /** @description The language the template's dynamic values are written in when their name names none, one of `en`, `sv`, `de`, `fr`, `es`, `nl`, `da`, `nb`, `fi`. Absent, the workspace's default language. A value whose name carries a language, `{date.long:sv}`, keeps it. */
                lang?: "en" | "sv" | "de" | "fr" | "es" | "nl" | "da" | "nb" | "fi";
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description The id of a published template. */
                    templateId?: unknown;
                    /** @description The customer's values for the template's fields. */
                    values?: unknown;
                } & {
                    blankId?: string;
                    placementId?: string;
                } & {
                    /** @description The linked group the placement is designed as part of: every placement one design drives, this one among them, each with whether its print is mirrored. The print is mirrored when this placement's entry says so, and a repeat on it is laid at one physical scale across the group: the document records the group and the width of its widest placement's print area (`linked.referenceWidthMm`). Needs `blankId` and `placementId`; each placement must be one of the blank's. */
                    linked?: {
                        /** @description Placements one design drives, two at least. */
                        placements: {
                            /** @description Whether the placement's print is mirrored left to right. */
                            mirror?: boolean;
                            /** @description The id of one of the blank's placements. */
                            placementId: string;
                        }[];
                    };
                    placementId?: string;
                } & {
                    heightMm?: number;
                    widthMm?: number;
                } & {
                    /** @description Whether the designer drew the customer's canvas at the template's own ratio, as the SDK mount option of that name sets it. The design is made at the chosen size through the template's fit either way, so this changes nothing in what is made. */
                    drawAtTemplateRatio?: boolean;
                } & {
                    /** @description A variant of the blank, by ref (`v_…`). On a blank whose print areas change with its size, the design is sized at, and keeps, that variant's size; a ref the blank has no variant of is refused with `variant_not_of_blank`. On any other blank it is not checked. A proof also keeps it as `proof_variant`, for display. */
                    variant?: string;
                    /** @description The size the design is for, as the blank's option values, such as `{"Size": "XL"}`, in place of `variant`: a value of each option the blank's print areas change with, and nothing else, or it is refused with `variant_row_invalid`. Ignored on a blank whose print areas change with nothing. */
                    variantRow?: {
                        [key: string]: string;
                    };
                } & {
                    /** @description Lays the design as a repeat of its template across the print area. Null, or absent, places it once. Through a designer link, a repeat the link offers, or null where its shopper may turn the repeat off; absent there, the link's own start. */
                    repeat?: {
                        /**
                         * @description How the tiles are laid: `grid` lines them up, `brick` moves every other row along by half a tile, `halfDrop` moves every other column down by half a tile, and `scatter` strews them at random places, turns and sizes, arranged by `seed`.
                         * @enum {string}
                         */
                        mode: "grid" | "brick" | "halfDrop" | "scatter";
                        /** @description Which arrangement a `scatter` draws: another seed is another arrangement of the same tile. Read by `scatter` only. */
                        seed: number;
                        /** @description The tile's width in percent of the print area's width, above 0 and at most 100; the tile keeps the template's shape. A tile that would print under 10 mm on a side is drawn at 10 mm. */
                        size: number;
                    } | null;
                };
            };
        };
        responses: {
            /** @description The payload is valid; the hash of the document it resolves to */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        docHash: string;
                        /** @description The pictures that print below `printFloorDpi` at the design's print size. A warning: nothing is refused for it. */
                        lowResolution: {
                            /** @description The picture's pixels along the edge that decides. */
                            actualPx: number;
                            assetId: string;
                            /** @description Pixels per inch along that edge, as printed. */
                            effectiveDpi: number;
                            /** @description The layer the picture fills, or the artwork's own key for its image background. */
                            layerId: string;
                            /** @description The pixels that edge needs at the floor. */
                            minPx: number;
                        }[];
                        /** @enum {boolean} */
                        ok: true;
                        /** @description The minimum print resolution the design's pictures were judged against: the template's own, else the tenant's. */
                        printFloorDpi: number;
                    };
                };
            };
            /** @description Refused: bad_json, bad_request, invalid_query */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `invalid_query`. */
                        reason?: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, feature_disabled, forbidden, workspace_suspended */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: constraint_violation, unknown_placement, variant_not_of_blank, variant_row_invalid, payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Sent with `payload_too_large`. */
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                        /** @description Always sent with `variant_not_of_blank`, `variant_row_invalid`. */
                        reason?: string;
                        /** @description Always sent with `variant_not_of_blank`. */
                        variant?: string;
                        /** @description Always sent with `constraint_violation`. */
                        violations?: {
                            /** @description On a `text_draws_fallback_glyphs` or `text_draws_missing_glyphs` warning: the characters the text's font cannot draw, each once, in the order the text first holds them. Absent on every other violation. */
                            characters?: string[];
                            given: unknown;
                            /** @description The language whose overrides break the rule, when only the template as it reads in that language does. Absent, the original. */
                            language?: string;
                            layerId: string;
                            prop: string;
                            rule: string;
                            /** @description `error` refuses a publish; `warning` is worth the author's attention and never does. */
                            severity: string;
                        }[];
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "webhookEndpoints.list": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The endpoints */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        active: boolean;
                        /** @description The key that owns the endpoint, and alone of the tenant's keys manages it: the secret key that registered it, or the integration key of the store it was given to. Null for one registered in the studio. */
                        apiKeyId: string | null;
                        /** @description The connected store the endpoint was registered for; null for one registered on its own. Such an endpoint is deleted by disconnecting the store. */
                        connectionId: string | null;
                        createdAt: number;
                        cursor: string | null;
                        eventTypes: string[];
                        failedCount: number;
                        failing: boolean;
                        id: string;
                        tenantId: string;
                        url: string;
                    }[];
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "webhookEndpoints.create": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @default [] */
                    eventTypes?: string[];
                    url: string;
                };
            };
        };
        responses: {
            /** @description The endpoint, and its signing secret, shown this once */
            201: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        endpointId: string;
                        secret: string;
                    };
                };
            };
            /** @description Refused: invalid_url, invalid_event_type, invalid_input */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `invalid_event_type`. */
                        type?: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "webhookEndpoints.delete": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The endpoint was deleted */
            204: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: connection_endpoint */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "webhookEndpoints.update": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    active?: boolean;
                    /** @description The event types it receives; empty for every type. */
                    eventTypes?: string[];
                };
            };
        };
        responses: {
            /** @description The endpoint */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        active: boolean;
                        /** @description The key that owns the endpoint, and alone of the tenant's keys manages it: the secret key that registered it, or the integration key of the store it was given to. Null for one registered in the studio. */
                        apiKeyId: string | null;
                        /** @description The connected store the endpoint was registered for; null for one registered on its own. Such an endpoint is deleted by disconnecting the store. */
                        connectionId: string | null;
                        createdAt: number;
                        cursor: string | null;
                        eventTypes: string[];
                        failedCount: number;
                        failing: boolean;
                        id: string;
                        tenantId: string;
                        url: string;
                    };
                };
            };
            /** @description Refused: invalid_event_type, invalid_input */
            400: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description Always sent with `invalid_event_type`. */
                        type?: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "webhookEndpoints.deliveries.list": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The endpoint's last deliveries, newest first */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description How many times the delivery was tried, the try under way included. Null once the record of its tries is cleared: 7 days after it was delivered, 90 after it failed. */
                        attempts: number | null;
                        createdAt: number;
                        eventId: string;
                        eventType: string;
                        id: string;
                        lastError: string | null;
                        nextAttemptAt: number | null;
                        status: string;
                    }[];
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "webhookEndpoints.deliveries.redeliverFailed": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description How many deliveries were requeued */
            202: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        requeued: number;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: endpoint_inactive */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "webhookEndpoints.deliveries.redeliver": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
                deliveryId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description How many deliveries were requeued */
            202: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        requeued: number;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: endpoint_inactive */
            409: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
    "webhookEndpoints.ping": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Whether the endpoint accepted the request */
            200: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @enum {boolean} */
                        delivered: true;
                    } | {
                        /** @enum {boolean} */
                        delivered: false;
                        error: string;
                    };
                };
            };
            /** @description Refused: unauthorized */
            401: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: origin_forbidden, forbidden, feature_disabled */
            403: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                        /** @description The feature the tenant does not have. Always sent with `feature_disabled`. */
                        feature?: string;
                    };
                };
            };
            /** @description Refused: not_found */
            404: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: payload_too_large */
            422: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        bytes?: number;
                        error: string;
                        /** @description Always sent with `payload_too_large`. */
                        maxBytes?: number;
                    };
                };
            };
            /** @description Refused: rate_limited */
            429: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                };
            };
            /** @description Refused: db_error. A request that failed unexpectedly answers as text instead. */
            500: {
                headers: {
                    "X-Request-Id": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: string;
                    };
                    "text/plain": "Internal Server Error";
                };
            };
        };
    };
}