@sixtyninecommerce/client 0.29.0 → 0.31.0

package/dist/generated/cms.d.ts

@@ -0,0 +1,2136 @@
+export interface paths {
+    "/assets/lookup": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Look up assets by IDs (public, channel-scoped)
+         * @description Bulk fetch by ID, max 50 per call. Returns the public-safe asset shape (id, mime, presets, alt translations). Used by storefronts to resolve image references stored in CMS field values.
+         */
+        get: operations["AssetsController_lookupAssets"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/channels/by-code/{code}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get a channel by code (public)
+         * @description Returns channel metadata plus the channel's Vendure customFields. Storefront clients use this as their single startup roundtrip — no separate Vendure call needed for things like maintenanceMode or cdnDomain.
+         */
+        get: operations["ChannelsController_findByCode"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/collections": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** List all collections */
+        get: operations["CollectionsController_findAll"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/collections/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get a collection by ID */
+        get: operations["CollectionsController_findOne"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/collections/{id}/items": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** List items in a collection */
+        get: operations["CollectionsController_findItems"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/collections/{id}/items/{itemId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get an item by ID */
+        get: operations["CollectionsController_findItem"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/collections/{id}/page-values": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get page content values for a collection */
+        get: operations["CollectionsController_getPageValues"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/content-strings": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** List all content strings */
+        get: operations["ContentStringsController_findAll"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/content-strings/export": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Export all content strings as flat JSON */
+        get: operations["ContentStringsController_export"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/content-strings/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get a content string by ID */
+        get: operations["ContentStringsController_findOne"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/forms": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** List all forms */
+        get: operations["FormsController_findAll"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/forms/by-slug/{slug}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get a form by slug */
+        get: operations["FormsController_findBySlug"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/forms/field-types": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** List the supported form field types, their config/validation schema, and the slug rules */
+        get: operations["FormsController_fieldTypes"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/forms/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get a form by ID */
+        get: operations["FormsController_findOne"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/forms/{id}/submit": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Submit a form (public endpoint) */
+        post: operations["FormsController_submit"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/items/lookup": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Look up items by IDs across collections (public, channel-scoped)
+         * @description Resolves CMS reference field values (e.g. content_item, multi_collection_ref) at runtime. A caller holding ReadCmsContent, UpdateCatalog or UpdateProduct on the channel sees all statuses; everyone else sees only published items. Rejects more than 50 IDs with 400 — batch on the caller side.
+         */
+        get: operations["ItemsController_lookup"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/items/lookup-with-fields": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Look up items by IDs with specific field values (public, channel-scoped)
+         * @description Like /items/lookup but additionally returns the requested field values for each item. Same status rule: all statuses for a ReadCmsContent, UpdateCatalog or UpdateProduct holder on the channel, published items only for everyone else.
+         */
+        get: operations["ItemsController_lookupWithFields"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/menus": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** List all menus */
+        get: operations["MenusController_findAll"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/menus/by-slug/{slug}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get a menu by slug */
+        get: operations["MenusController_findBySlug"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/menus/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get a menu by ID */
+        get: operations["MenusController_findOne"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/public-assets/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get a single asset by ID (public, channel-scoped)
+         * @description Public-safe single asset fetch by ID. Used by storefronts at runtime when a content item references an image by ID.
+         */
+        get: operations["AssetsController_findPublicAssetById"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/resolve": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Resolve a URL path to content */
+        get: operations["ResolveController_resolve"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/search/collection-items": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Search collection items */
+        get: operations["SearchController_searchCollectionItems"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/sitemap": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get all routable published items for the channel */
+        get: operations["ResolveController_sitemap"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/vendure-assets/lookup": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Bulk look up Vendure asset descriptions (public, channel-scoped)
+         * @description Returns alt-text translations for the given Vendure asset IDs, grouped by Vendure asset ID. Max 50 per call. Used by storefronts to resolve product image alt text in multiple languages.
+         */
+        get: operations["AssetsController_lookupVendureAssetDescriptions"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+}
+export type webhooks = Record<string, never>;
+export interface components {
+    schemas: {
+        PublicAssetDto: {
+            alt_text: string | null;
+            content_hash: string | null;
+            /** @description Bytes. */
+            file_size: number;
+            filename: string;
+            height: number | null;
+            /** Format: uuid */
+            id: string;
+            mime_type: string;
+            /** @description Storage keys of every image preset. Null for anything that is not a raster image. */
+            presets: components["schemas"]["PublicAssetPresetsDto"] | null;
+            /** @description Object key in the channel’s asset storage (`<channel code>/content/…`). */
+            storage_key: string;
+            /** @description Per-language alt text. */
+            translations: components["schemas"]["PublicAssetTranslationDto"][];
+            width: number | null;
+        };
+        PublicAssetListResponseDto: {
+            /** @description The ids that resolved (at most the first 50 sent), in no guaranteed order; an unknown id is simply absent. */
+            data: components["schemas"]["PublicAssetDto"][];
+        };
+        PublicAssetPresetUrlsDto: {
+            /** @description Storage key of the preset rendition in the original format. */
+            url: string;
+            /** @description Storage key of the WebP rendition. */
+            webp_url: string;
+        };
+        PublicAssetPresetsDto: {
+            l: components["schemas"]["PublicAssetPresetUrlsDto"];
+            m: components["schemas"]["PublicAssetPresetUrlsDto"];
+            s: components["schemas"]["PublicAssetPresetUrlsDto"];
+            xl: components["schemas"]["PublicAssetPresetUrlsDto"];
+            xs: components["schemas"]["PublicAssetPresetUrlsDto"];
+            xxs: components["schemas"]["PublicAssetPresetUrlsDto"];
+        };
+        PublicAssetResponseDto: {
+            data: components["schemas"]["PublicAssetDto"];
+        };
+        PublicAssetTranslationDto: {
+            alt_text: string;
+            language_code: string;
+        };
+        PublicBreadcrumbDto: {
+            /** Format: uuid */
+            id: string;
+            path: string | null;
+            /** @description The translated slug for `locale` when one exists; null for an ancestor that has no slug. */
+            slug: string | null;
+        };
+        PublicChannelDto: {
+            code: string;
+            /** @description The channel's public Vendure custom fields, as the Shop API's `activeChannel` returns them (so organization-inherited branding already carries the organization's values). Every key is optional and nullable; the object is empty while Vendure is unreachable. Cached by the CMS for up to 60 seconds. */
+            custom_fields: {
+                addressLine1?: string | null;
+                addressLine2?: string | null;
+                businessDescription?: string | null;
+                businessName?: string | null;
+                cdnDomain?: string | null;
+                city?: string | null;
+                commercePathPrefix?: string | null;
+                commercePathPrefixTranslations?: string | null;
+                contactEmail?: string | null;
+                contactPhone?: string | null;
+                country?: string | null;
+                coverAssetId?: string | null;
+                darkLogoAssetId?: string | null;
+                faviconAssetId?: string | null;
+                legalName?: string | null;
+                logoAssetId?: string | null;
+                maintenanceMode?: boolean | null;
+                postalCode?: string | null;
+                primaryColor?: string | null;
+                province?: string | null;
+                registrationNumber?: string | null;
+                socialLinks?: string | null;
+                storefrontUrl?: string | null;
+                urlLocalePrefixDefault?: boolean | null;
+                urlLocaleStrategy?: string | null;
+                vatNumber?: string | null;
+                websiteUrl?: string | null;
+            } & {
+                [key: string]: unknown;
+            };
+            default_currency_code: string;
+            default_language_code: string;
+            /** Format: uuid */
+            id: string;
+            /** @description Present only when the code asked for is a renamed store's OLD code, still answering for its storefronts: that old code. `code` is then the store's current code, which a storefront should be configured with before `previous_code_until`. The response also carries `Deprecation`, `Sunset` and `Link: <…>; rel="successor-version"` headers. */
+            previous_code?: string;
+            /**
+             * Format: date-time
+             * @description With `previous_code`: when the old code stops answering (a 404 after it, like any unknown code).
+             */
+            previous_code_until?: string;
+            /** @description Whether the channel stores prices tax-inclusive. False while Vendure is unreachable — read it together with `custom_fields`, which is then empty. */
+            prices_include_tax: boolean;
+            /**
+             * Format: date-time
+             * @description With `previous_code`: when the store was renamed away from it.
+             */
+            renamed_at?: string;
+            /** @description The channel's token, sent as `vendure-token` on Shop API calls. */
+            token: string;
+        };
+        PublicChannelResponseDto: {
+            data: components["schemas"]["PublicChannelDto"];
+        };
+        PublicCollectionDetailDto: {
+            /** @description URL prefix of routable items; null when the collection is not routable. */
+            basePath: string | null;
+            /** Format: uuid */
+            channelId: string;
+            /** Format: date-time */
+            createdAt: string;
+            description: string | null;
+            /** @description Live top-level fields of both scopes, ordered by `position`. */
+            fields: components["schemas"]["PublicCollectionFieldDto"][];
+            /** Format: uuid */
+            id: string;
+            isHierarchical: boolean;
+            isSingleton: boolean;
+            name: string;
+            /**
+             * Format: date-time
+             * @description Soft-removal instant. Always null here: removed rows are not served.
+             */
+            removedAt: string | null;
+            slug: string;
+            titleFieldSlug: string | null;
+            /** Format: date-time */
+            updatedAt: string;
+        };
+        PublicCollectionDto: {
+            /** @description URL prefix of routable items; null when the collection is not routable. */
+            basePath: string | null;
+            /** Format: uuid */
+            channelId: string;
+            /** Format: date-time */
+            createdAt: string;
+            description: string | null;
+            /** Format: uuid */
+            id: string;
+            isHierarchical: boolean;
+            isSingleton: boolean;
+            name: string;
+            /**
+             * Format: date-time
+             * @description Soft-removal instant. Always null here: removed rows are not served.
+             */
+            removedAt: string | null;
+            slug: string;
+            titleFieldSlug: string | null;
+            /** Format: date-time */
+            updatedAt: string;
+        };
+        PublicCollectionFieldDto: {
+            /** Format: uuid */
+            collectionId: string;
+            /** @description Type-specific configuration (limits, options, reference targets). */
+            config: {
+                [key: string]: unknown;
+            } | null;
+            /** Format: date-time */
+            createdAt: string;
+            /** @description The field type (`string`, `text`, `image`, `group`, `product`, … — see the field-type registry). */
+            fieldType: string;
+            /**
+             * Format: uuid
+             * @description The group field this sub-field belongs to; null for a top-level field.
+             */
+            groupId: string | null;
+            groupPosition: number;
+            helpText: string | null;
+            /** Format: uuid */
+            id: string;
+            isLocalizable: boolean;
+            isRequired: boolean;
+            name: string;
+            position: number;
+            /**
+             * Format: date-time
+             * @description Soft-removal instant. Always null here: removed rows are not served.
+             */
+            removedAt: string | null;
+            /**
+             * @description `item` fields hold entry values; `page` fields hold the collection page values.
+             * @enum {string}
+             */
+            scope: "item" | "page";
+            slug: string;
+            /** @description A `group` field's sub-fields, ordered by `groupPosition`. Present only on group fields of `GET /collections/:id`. */
+            subFields?: components["schemas"]["PublicCollectionFieldDto"][];
+            /** Format: date-time */
+            updatedAt: string;
+        };
+        PublicCollectionItemDetailDto: {
+            /** Format: uuid */
+            channelId: string;
+            /** Format: uuid */
+            collectionId: string;
+            /** Format: date-time */
+            createdAt: string;
+            /** Format: uuid */
+            id: string;
+            /** Format: uuid */
+            parentId: string | null;
+            /** @description The routed URL path; null when the item is not routable (its collection has no base path, or it has no slug). */
+            path: string | null;
+            position: number;
+            /** Format: date-time */
+            publishedAt: string | null;
+            /**
+             * Format: date-time
+             * @description Soft-removal instant. Always null here: removed rows are not served.
+             */
+            removedAt: string | null;
+            slug: string | null;
+            /** @description The translated slug rows as stored. `slug_translations` is the same data keyed by language. */
+            slugTranslations: components["schemas"]["PublicItemSlugTranslationEntityDto"][];
+            /** @description Translated slug and path per language code. */
+            slug_translations: {
+                [key: string]: {
+                    path: string | null;
+                    slug: string;
+                };
+            };
+            /** @description `draft`, `published` or `archived`. A caller without ReadCmsContent on the channel is served published items only. */
+            status: string;
+            /** Format: date-time */
+            updatedAt: string;
+            /** @description Field values keyed by field slug. With `language_code`, the localized value where one is stored, else the base value; without it, base values only. */
+            values: {
+                [key: string]: unknown;
+            };
+        };
+        PublicCollectionItemDto: {
+            /** Format: uuid */
+            channelId: string;
+            /** Format: uuid */
+            collectionId: string;
+            /** Format: date-time */
+            createdAt: string;
+            /** Format: uuid */
+            id: string;
+            /** Format: uuid */
+            parentId: string | null;
+            /** @description The routed URL path; null when the item is not routable (its collection has no base path, or it has no slug). */
+            path: string | null;
+            position: number;
+            /** Format: date-time */
+            publishedAt: string | null;
+            /**
+             * Format: date-time
+             * @description Soft-removal instant. Always null here: removed rows are not served.
+             */
+            removedAt: string | null;
+            slug: string | null;
+            /** @description `draft`, `published` or `archived`. A caller without ReadCmsContent on the channel is served published items only. */
+            status: string;
+            /** Format: date-time */
+            updatedAt: string;
+            /** @description Field values keyed by field slug. With `language_code`, the localized value where one is stored, else the base value; without it, base values only. */
+            values: {
+                [key: string]: unknown;
+            };
+        };
+        PublicCollectionItemListResponseDto: {
+            data: components["schemas"]["PublicCollectionItemDto"][];
+            has_next: boolean;
+            /** @description Cursor mode only (`?after=` sent, or `?limit=` of 1-200 without `offset` or `sort`; never with `search`): the same page as `data`. */
+            items?: components["schemas"]["PublicCollectionItemDto"][];
+            /** @description The cursor of the next page; always null outside cursor mode (see `items`). */
+            next_cursor: string | null;
+            pagination: components["schemas"]["PublicPaginationTotalDto"];
+        };
+        PublicCollectionItemResponseDto: {
+            data: components["schemas"]["PublicCollectionItemDetailDto"];
+        };
+        PublicCollectionItemSearchResponseDto: {
+            data: components["schemas"]["PublicCollectionItemSearchResultDto"];
+        };
+        PublicCollectionItemSearchResultDto: {
+            /** @description Matching items in rank order. Field values ride flattened on each hit as `<field slug>` (base) and `<field slug>_<language>` (localized) keys; a field whose key equals one of the fixed keys is not flattened, since the fixed keys are always the item's own. */
+            hits: ({
+                /** Format: uuid */
+                channel_id: string;
+                /** Format: uuid */
+                collection_id: string;
+                collection_slug: string;
+                /** @description Epoch milliseconds. */
+                created_at: number;
+                /** Format: uuid */
+                id: string;
+                /** Format: uuid */
+                parent_id: string | null;
+                path: string | null;
+                position: number;
+                /** @description Epoch milliseconds. */
+                published_at: number | null;
+                slug: string | null;
+                status: string;
+                /** @description Epoch milliseconds. */
+                updated_at: number;
+            } & {
+                [key: string]: unknown;
+            })[];
+            /** @description The page size applied (default 20, at most 100). */
+            limit: number;
+            offset: number;
+            processing_time_ms: number;
+            /** @description Meilisearch's estimated total of matching items. */
+            total: number;
+        };
+        PublicCollectionListResponseDto: {
+            data: components["schemas"]["PublicCollectionDto"][];
+            /** @description Cursor mode only. */
+            has_next?: boolean;
+            /** @description Cursor mode only (`?after=` sent): the same page as `data`. */
+            items?: components["schemas"]["PublicCollectionDto"][];
+            /** @description Cursor mode only: the cursor of the next page, or null on the last one. */
+            next_cursor?: string | null;
+        };
+        PublicCollectionPageValuesDto: {
+            /** @description The collection's live top-level `page` fields, ordered by `position`. */
+            fields: components["schemas"]["PublicCollectionFieldDto"][];
+            /** @description Page values keyed by field slug: the requested language where one is stored, else the base value. */
+            values: {
+                [key: string]: unknown;
+            };
+        };
+        PublicCollectionPageValuesResponseDto: {
+            data: components["schemas"]["PublicCollectionPageValuesDto"];
+        };
+        PublicCollectionResponseDto: {
+            data: components["schemas"]["PublicCollectionDetailDto"];
+        };
+        PublicContentStringDto: {
+            /** Format: uuid */
+            channelId: string;
+            /** Format: date-time */
+            createdAt: string;
+            description: string | null;
+            /** Format: uuid */
+            id: string;
+            key: string;
+            /**
+             * Format: date-time
+             * @description Soft-removal instant. Always null here: removed rows are not served.
+             */
+            removedAt: string | null;
+            /** Format: date-time */
+            updatedAt: string;
+            /** @description One value per language, in no guaranteed order. */
+            values: components["schemas"]["PublicContentStringValueDto"][];
+        };
+        PublicContentStringListResponseDto: {
+            data: components["schemas"]["PublicContentStringDto"][];
+            has_next: boolean;
+            /** @description Cursor mode only (`?after=` sent): the same page as `data`. */
+            items?: components["schemas"]["PublicContentStringDto"][];
+            /** @description The cursor of the next page; always null outside cursor mode. */
+            next_cursor: string | null;
+            pagination: components["schemas"]["PublicPaginationTotalDto"];
+        };
+        PublicContentStringResponseDto: {
+            data: components["schemas"]["PublicContentStringDto"];
+        };
+        PublicContentStringValueDto: {
+            /** Format: uuid */
+            contentStringId: string;
+            /** Format: date-time */
+            createdAt: string;
+            /** Format: uuid */
+            id: string;
+            languageCode: string;
+            /** Format: date-time */
+            updatedAt: string;
+            value: string;
+        };
+        PublicFormDto: {
+            /** @description Live fields ordered by `position`. EMPTY on the list route (`GET /forms`), which does not load them — fetch one form for its fields. */
+            fields: components["schemas"]["PublicFormFieldDto"][];
+            /** @description Whether a team notification is sent on submit (the recipients are never exposed). */
+            hasNotifications: boolean;
+            /** Format: uuid */
+            id: string;
+            name: string;
+            redirectUrlOnSuccess: string | null;
+            /** @description Whether the visitor is sent a confirmation email on submit. */
+            sendsConfirmation: boolean;
+            slug: string;
+            /** @description Form-level translations. EMPTY on the list route (`GET /forms`), like `fields`. */
+            translations: components["schemas"]["PublicFormTranslationDto"][];
+        };
+        PublicFormFieldConstraintDto: {
+            description: string;
+            /** @description The key, read from `validation` first, then `config`. */
+            key: string;
+            /** @enum {string} */
+            valueType: "integer" | "number" | "string" | "string[]";
+        };
+        PublicFormFieldDto: {
+            /** @description Type-specific configuration; `{}` when none. */
+            config: {
+                [key: string]: unknown;
+            };
+            /** @description The label in the requested `locale` (exact tag, then its base language), else the field's name. */
+            label: string;
+            position: number;
+            required: boolean;
+            slug: string;
+            /** @description The field type — see `GET /forms/field-types`. */
+            type: string;
+            /** @description The constraints enforced on submit (only recognized keys of the field type); mirror them to validate client-side. */
+            validation: {
+                [key: string]: unknown;
+            };
+        };
+        PublicFormFieldTypeDto: {
+            constraints: components["schemas"]["PublicFormFieldConstraintDto"][];
+            description: string;
+            label: string;
+            notes?: string;
+            /** @enum {string} */
+            type: "text" | "textarea" | "email" | "phone" | "number" | "select" | "checkbox" | "radio" | "date" | "file" | "hidden";
+            /** @description The shape a submission sends for this type. */
+            valueType: string;
+        };
+        PublicFormFieldTypesMetaDto: {
+            slugRules: components["schemas"]["PublicFormSlugRulesDto"];
+        };
+        PublicFormFieldTypesResponseDto: {
+            data: components["schemas"]["PublicFormFieldTypeDto"][];
+            meta: components["schemas"]["PublicFormFieldTypesMetaDto"];
+        };
+        PublicFormListResponseDto: {
+            /** @description Forms, each projected. A caller holding ReadCmsForm on the channel receives the full form entity instead (the editor view, not described here). */
+            data: components["schemas"]["PublicFormDto"][];
+            has_next: boolean;
+            /** @description Cursor mode only (`?after=` sent, or `?limit=` of 1-200 without `offset` or `sort`): the same page as `data`. */
+            items?: components["schemas"]["PublicFormDto"][];
+            /** @description The cursor of the next page; always null outside cursor mode (see `items`). */
+            next_cursor: string | null;
+            pagination: components["schemas"]["PublicPaginationTotalDto"];
+        };
+        PublicFormResponseDto: {
+            /** @description The form, projected. A caller holding ReadCmsForm on the channel receives the full form entity instead (the editor view, not described here). */
+            data: components["schemas"]["PublicFormDto"];
+        };
+        PublicFormSlugRuleDto: {
+            description: string;
+            invalidExamples: string[];
+            maxLength: number;
+            /** @description Source of the regular expression a slug must match. */
+            pattern: string;
+            validExamples: string[];
+        };
+        PublicFormSlugRulesDto: {
+            field: components["schemas"]["PublicFormSlugRuleDto"];
+            form: components["schemas"]["PublicFormSlugRuleDto"];
+        };
+        PublicFormSubmissionDto: {
+            /** Format: date-time */
+            created_at: string;
+            /** Format: uuid */
+            id: string;
+        };
+        PublicFormSubmissionResponseDto: {
+            data: components["schemas"]["PublicFormSubmissionDto"];
+        };
+        PublicFormTranslationDto: {
+            description: string | null;
+            languageCode: string;
+            submitButtonText: string | null;
+            successMessage: string | null;
+            title: string;
+        };
+        PublicItemLookupResponseDto: {
+            /** @description The ids that resolved, in no guaranteed order; an unknown id is simply absent. */
+            data: components["schemas"]["PublicItemSummaryDto"][];
+        };
+        PublicItemLookupWithFieldsResponseDto: {
+            data: components["schemas"]["PublicItemWithFieldsDto"][];
+        };
+        PublicItemSlugTranslationEntityDto: {
+            /** Format: uuid */
+            channelId: string;
+            /** Format: uuid */
+            collectionId: string;
+            /** Format: date-time */
+            createdAt: string;
+            /** Format: uuid */
+            id: string;
+            /** Format: uuid */
+            itemId: string;
+            languageCode: string;
+            path: string | null;
+            slug: string;
+            /** Format: date-time */
+            updatedAt: string;
+        };
+        PublicItemSummaryDto: {
+            /** Format: uuid */
+            collection_id: string;
+            collection_name: string;
+            collection_title_field_slug: string | null;
+            /** Format: uuid */
+            id: string;
+            slug: string | null;
+            /** @description `draft`, `published` or `archived`; published only unless the caller holds ReadCmsContent, UpdateCatalog or UpdateProduct on the channel. */
+            status: string;
+            /** @description The item's base title-field value when it is a string, else null. */
+            title: string | null;
+        };
+        PublicItemWithFieldsDto: {
+            /** @description Base (unlocalized) values of the requested field slugs; a slug with no stored value is absent. */
+            fieldValues: {
+                [key: string]: unknown;
+            };
+            /** Format: uuid */
+            id: string;
+            title: string | null;
+        };
+        PublicMenuDetailDto: {
+            /** Format: uuid */
+            channelId: string;
+            /** Format: date-time */
+            createdAt: string;
+            description: string | null;
+            /** Format: uuid */
+            id: string;
+            items: components["schemas"]["PublicMenuItemDto"][];
+            /** @description Free-form presentation data for the menu as a whole. */
+            metadata: {
+                [key: string]: unknown;
+            } | null;
+            name: string;
+            /**
+             * Format: date-time
+             * @description Soft-removal instant. Always null here: removed rows are not served.
+             */
+            removedAt: string | null;
+            slug: string;
+            /** Format: date-time */
+            updatedAt: string;
+        };
+        PublicMenuItemBaseDto: {
+            /** Format: date-time */
+            createdAt: string;
+            /** Format: uuid */
+            id: string;
+            /** @description `internal`, `external`, `collection_item`, `collection_page`, `heading`, `product` or `product_collection`. */
+            itemType: string;
+            /** Format: uuid */
+            menuId: string;
+            metadata: {
+                [key: string]: unknown;
+            } | null;
+            openInNewTab: boolean;
+            /** @description Always null on these reads (the relation is not loaded); read `parentId`. */
+            parent: {
+                [key: string]: unknown;
+            } | null;
+            /** Format: uuid */
+            parentId: string | null;
+            position: number;
+            /**
+             * Format: date-time
+             * @description Soft-removal instant. Always null here: removed rows are not served.
+             */
+            removedAt: string | null;
+            /** @description The linked entity: a CMS item or collection UUID, or a Vendure product/collection id. */
+            targetId: string | null;
+            /** Format: date-time */
+            updatedAt: string;
+            /** @description The link of an `internal` or `external` item. */
+            url: string | null;
+        };
+        PublicMenuItemDto: {
+            /** @description Direct live children, without their translations or their own children (each also appears in the menu’s flat `items`). */
+            children: components["schemas"]["PublicMenuItemBaseDto"][];
+            /** Format: date-time */
+            createdAt: string;
+            /** Format: uuid */
+            id: string;
+            /** @description `internal`, `external`, `collection_item`, `collection_page`, `heading`, `product` or `product_collection`. */
+            itemType: string;
+            /** Format: uuid */
+            menuId: string;
+            metadata: {
+                [key: string]: unknown;
+            } | null;
+            openInNewTab: boolean;
+            /** @description Always null on these reads (the relation is not loaded); read `parentId`. */
+            parent: {
+                [key: string]: unknown;
+            } | null;
+            /** Format: uuid */
+            parentId: string | null;
+            position: number;
+            /**
+             * Format: date-time
+             * @description Soft-removal instant. Always null here: removed rows are not served.
+             */
+            removedAt: string | null;
+            /** @description The URL path a top-level `collection_item` or `collection_page` item links to, when its target resolves to a non-empty path in this channel; absent otherwise. */
+            resolvedPath?: string;
+            /** @description The linked entity: a CMS item or collection UUID, or a Vendure product/collection id. */
+            targetId: string | null;
+            translations: components["schemas"]["PublicMenuItemTranslationDto"][];
+            /** Format: date-time */
+            updatedAt: string;
+            /** @description The link of an `internal` or `external` item. */
+            url: string | null;
+        };
+        PublicMenuItemTranslationDto: {
+            /** Format: date-time */
+            createdAt: string;
+            /** Format: uuid */
+            id: string;
+            label: string;
+            languageCode: string;
+            /** Format: uuid */
+            menuItemId: string;
+            title: string | null;
+            /** Format: date-time */
+            updatedAt: string;
+        };
+        PublicMenuListResponseDto: {
+            data: components["schemas"]["PublicMenuSummaryDto"][];
+            has_next: boolean;
+            /** @description Cursor mode only (`?after=` sent, or `?limit=` of 1-200 without `offset` or `sort`): the same page as `data`. */
+            items?: components["schemas"]["PublicMenuSummaryDto"][];
+            /** @description The cursor of the next page; always null outside cursor mode (see `items`). */
+            next_cursor: string | null;
+            pagination: components["schemas"]["PublicPaginationTotalDto"];
+        };
+        PublicMenuResponseDto: {
+            data: components["schemas"]["PublicMenuDetailDto"];
+        };
+        PublicMenuSummaryDto: {
+            /** Format: uuid */
+            channelId: string;
+            /** Format: date-time */
+            createdAt: string;
+            description: string | null;
+            /** Format: uuid */
+            id: string;
+            /** @description Live items in the menu, nested ones included. */
+            itemCount: number;
+            /** @description Free-form presentation data for the menu as a whole. */
+            metadata: {
+                [key: string]: unknown;
+            } | null;
+            name: string;
+            /**
+             * Format: date-time
+             * @description Soft-removal instant. Always null here: removed rows are not served.
+             */
+            removedAt: string | null;
+            slug: string;
+            /** Format: date-time */
+            updatedAt: string;
+        };
+        PublicPaginationTotalDto: {
+            /** @description Rows matching the request, across every page. */
+            total: number;
+        };
+        PublicResolveResponseDto: {
+            data: components["schemas"]["PublicResolvedContentDto"];
+        };
+        PublicResolvedCollectionDto: {
+            basePath: string | null;
+            /** @description Live top-level fields: for an item, the collection's fields; for a collection page, its `page` fields only. */
+            fields: components["schemas"]["PublicResolvedFieldDto"][];
+            /** Format: uuid */
+            id: string;
+            isHierarchical: boolean;
+            isSingleton: boolean;
+            name: string;
+            slug: string;
+            titleFieldSlug: string | null;
+        };
+        PublicResolvedContentDto: {
+            /** @description The ancestor chain, root first, ending with the item itself. Absent for a collection page. */
+            breadcrumbs?: components["schemas"]["PublicBreadcrumbDto"][];
+            collection: components["schemas"]["PublicResolvedCollectionDto"];
+            /** @description The resolved item. Absent for a collection page. */
+            item?: components["schemas"]["PublicResolvedItemDto"];
+            /** @description Null when the values carry none of the standard SEO fields. */
+            metadata: components["schemas"]["PublicSeoMetadataDto"] | null;
+            /** @description Translated slug and path per language code. Absent for a collection page. */
+            slug_translations?: {
+                [key: string]: {
+                    path: string | null;
+                    slug: string;
+                };
+            };
+            /**
+             * @description Present only when the path is a collection's index page (its `basePath`).
+             * @enum {string}
+             */
+            type?: "collection_page";
+            /** @description Field values keyed by field slug. For a collection page, its page values: the `locale` value where one is stored, else the base value. For an item, each field's base value or its `locale` value, with no precedence between the two when both are stored; without `locale`, a value in any stored language may be returned. */
+            values: {
+                [key: string]: unknown;
+            };
+        };
+        PublicResolvedFieldDto: {
+            /** @description The field type (`string`, `image`, `group`, …). */
+            fieldType: string;
+            isLocalizable: boolean;
+            name: string;
+            slug: string;
+            /** @description A `group` field's live sub-fields, ordered by position. Present only on group fields. */
+            subFields?: components["schemas"]["PublicResolvedSubFieldDto"][];
+        };
+        PublicResolvedItemDto: {
+            /** Format: date-time */
+            createdAt: string;
+            /** Format: uuid */
+            id: string;
+            /** Format: uuid */
+            parentId: string | null;
+            path: string | null;
+            position: number;
+            /** Format: date-time */
+            publishedAt: string | null;
+            slug: string | null;
+            /** @description `published`, unless a caller holding ReadCmsContent on the channel asked for another `status`. */
+            status: string;
+            /** Format: date-time */
+            updatedAt: string;
+        };
+        PublicResolvedSubFieldDto: {
+            fieldType: string;
+            isRequired: boolean;
+            name: string;
+            slug: string;
+        };
+        PublicSeoMetadataDto: {
+            aiSummary: string | number | boolean | unknown[] | ({
+                [key: string]: unknown;
+            } | null);
+            canonicalUrl: string | number | boolean | unknown[] | ({
+                [key: string]: unknown;
+            } | null);
+            /** @description The stored `nofollow` value, or false. */
+            nofollow: string | number | boolean | unknown[] | ({
+                [key: string]: unknown;
+            } | null);
+            /** @description The stored `noindex` value, or false. */
+            noindex: string | number | boolean | unknown[] | ({
+                [key: string]: unknown;
+            } | null);
+            /** @description The raw `og_image` field value (an asset reference). */
+            ogImage: string | number | boolean | unknown[] | ({
+                [key: string]: unknown;
+            } | null);
+            /** @description The stored `seo_description` value, or null. */
+            seoDescription: string | number | boolean | unknown[] | ({
+                [key: string]: unknown;
+            } | null);
+            /** @description The stored `seo_title` value, or null. */
+            seoTitle: string | number | boolean | unknown[] | ({
+                [key: string]: unknown;
+            } | null);
+            socialDescription: string | number | boolean | unknown[] | ({
+                [key: string]: unknown;
+            } | null);
+            /** @description Always null today. */
+            socialImageAlt: string | number | boolean | unknown[] | ({
+                [key: string]: unknown;
+            } | null);
+            socialTitle: string | number | boolean | unknown[] | ({
+                [key: string]: unknown;
+            } | null);
+        };
+        PublicSitemapEntryDto: {
+            /**
+             * Format: uuid
+             * @description Present on item entries only.
+             */
+            collection_id?: string | null;
+            collection_slug: string | null;
+            /**
+             * Format: uuid
+             * @description The item id, or the collection id for a collection page.
+             */
+            id: string;
+            /** @description Present on every entry when `language_code` was sent. */
+            language_code?: string;
+            /** @description The URL path (for `language_code`, the translated path where one exists). A collection page is `basePath`, which may be the empty string. */
+            path: string | null;
+            /** @description Present on item entries when `include_seo=1` was sent; null when the item has no SEO values. */
+            seo?: components["schemas"]["PublicSitemapSeoDto"] | null;
+            /** @description The item's title-field value, or the collection's name for a collection page. */
+            title: string | null;
+            /**
+             * @description Present only on a collection's index page entry.
+             * @enum {string}
+             */
+            type?: "collection_page";
+            /** Format: date-time */
+            updated_at: string;
+        };
+        PublicSitemapResponseDto: {
+            /** @description Collection pages first, then published routable items ordered by path. */
+            data: components["schemas"]["PublicSitemapEntryDto"][];
+        };
+        PublicSitemapSeoDto: {
+            noindex: boolean;
+            seo_description: string | null;
+            seo_title: string | null;
+        };
+        PublicVendureAssetDescriptionDto: {
+            description: string;
+            language_code: string;
+        };
+        PublicVendureAssetDescriptionsLookupResponseDto: {
+            /** @description Descriptions grouped by Vendure asset id (at most the first 50 sent). An id with no descriptions is absent. */
+            data: {
+                [key: string]: components["schemas"]["PublicVendureAssetDescriptionDto"][];
+            };
+        };
+        SubmitFormDto: {
+            /** @description Form data */
+            data: Record<string, unknown>;
+            /** @description Locale code for responses */
+            locale_code?: string;
+        };
+    };
+    responses: never;
+    parameters: never;
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+}
+export type PublicAssetDto = components['schemas']['PublicAssetDto'];
+export type PublicAssetListResponseDto = components['schemas']['PublicAssetListResponseDto'];
+export type PublicAssetPresetUrlsDto = components['schemas']['PublicAssetPresetUrlsDto'];
+export type PublicAssetPresetsDto = components['schemas']['PublicAssetPresetsDto'];
+export type PublicAssetResponseDto = components['schemas']['PublicAssetResponseDto'];
+export type PublicAssetTranslationDto = components['schemas']['PublicAssetTranslationDto'];
+export type PublicBreadcrumbDto = components['schemas']['PublicBreadcrumbDto'];
+export type PublicChannelDto = components['schemas']['PublicChannelDto'];
+export type PublicChannelResponseDto = components['schemas']['PublicChannelResponseDto'];
+export type PublicCollectionDetailDto = components['schemas']['PublicCollectionDetailDto'];
+export type PublicCollectionDto = components['schemas']['PublicCollectionDto'];
+export type PublicCollectionFieldDto = components['schemas']['PublicCollectionFieldDto'];
+export type PublicCollectionItemDetailDto = components['schemas']['PublicCollectionItemDetailDto'];
+export type PublicCollectionItemDto = components['schemas']['PublicCollectionItemDto'];
+export type PublicCollectionItemListResponseDto = components['schemas']['PublicCollectionItemListResponseDto'];
+export type PublicCollectionItemResponseDto = components['schemas']['PublicCollectionItemResponseDto'];
+export type PublicCollectionItemSearchResponseDto = components['schemas']['PublicCollectionItemSearchResponseDto'];
+export type PublicCollectionItemSearchResultDto = components['schemas']['PublicCollectionItemSearchResultDto'];
+export type PublicCollectionListResponseDto = components['schemas']['PublicCollectionListResponseDto'];
+export type PublicCollectionPageValuesDto = components['schemas']['PublicCollectionPageValuesDto'];
+export type PublicCollectionPageValuesResponseDto = components['schemas']['PublicCollectionPageValuesResponseDto'];
+export type PublicCollectionResponseDto = components['schemas']['PublicCollectionResponseDto'];
+export type PublicContentStringDto = components['schemas']['PublicContentStringDto'];
+export type PublicContentStringListResponseDto = components['schemas']['PublicContentStringListResponseDto'];
+export type PublicContentStringResponseDto = components['schemas']['PublicContentStringResponseDto'];
+export type PublicContentStringValueDto = components['schemas']['PublicContentStringValueDto'];
+export type PublicFormDto = components['schemas']['PublicFormDto'];
+export type PublicFormFieldConstraintDto = components['schemas']['PublicFormFieldConstraintDto'];
+export type PublicFormFieldDto = components['schemas']['PublicFormFieldDto'];
+export type PublicFormFieldTypeDto = components['schemas']['PublicFormFieldTypeDto'];
+export type PublicFormFieldTypesMetaDto = components['schemas']['PublicFormFieldTypesMetaDto'];
+export type PublicFormFieldTypesResponseDto = components['schemas']['PublicFormFieldTypesResponseDto'];
+export type PublicFormListResponseDto = components['schemas']['PublicFormListResponseDto'];
+export type PublicFormResponseDto = components['schemas']['PublicFormResponseDto'];
+export type PublicFormSlugRuleDto = components['schemas']['PublicFormSlugRuleDto'];
+export type PublicFormSlugRulesDto = components['schemas']['PublicFormSlugRulesDto'];
+export type PublicFormSubmissionDto = components['schemas']['PublicFormSubmissionDto'];
+export type PublicFormSubmissionResponseDto = components['schemas']['PublicFormSubmissionResponseDto'];
+export type PublicFormTranslationDto = components['schemas']['PublicFormTranslationDto'];
+export type PublicItemLookupResponseDto = components['schemas']['PublicItemLookupResponseDto'];
+export type PublicItemLookupWithFieldsResponseDto = components['schemas']['PublicItemLookupWithFieldsResponseDto'];
+export type PublicItemSlugTranslationEntityDto = components['schemas']['PublicItemSlugTranslationEntityDto'];
+export type PublicItemSummaryDto = components['schemas']['PublicItemSummaryDto'];
+export type PublicItemWithFieldsDto = components['schemas']['PublicItemWithFieldsDto'];
+export type PublicMenuDetailDto = components['schemas']['PublicMenuDetailDto'];
+export type PublicMenuItemBaseDto = components['schemas']['PublicMenuItemBaseDto'];
+export type PublicMenuItemDto = components['schemas']['PublicMenuItemDto'];
+export type PublicMenuItemTranslationDto = components['schemas']['PublicMenuItemTranslationDto'];
+export type PublicMenuListResponseDto = components['schemas']['PublicMenuListResponseDto'];
+export type PublicMenuResponseDto = components['schemas']['PublicMenuResponseDto'];
+export type PublicMenuSummaryDto = components['schemas']['PublicMenuSummaryDto'];
+export type PublicPaginationTotalDto = components['schemas']['PublicPaginationTotalDto'];
+export type PublicResolveResponseDto = components['schemas']['PublicResolveResponseDto'];
+export type PublicResolvedCollectionDto = components['schemas']['PublicResolvedCollectionDto'];
+export type PublicResolvedContentDto = components['schemas']['PublicResolvedContentDto'];
+export type PublicResolvedFieldDto = components['schemas']['PublicResolvedFieldDto'];
+export type PublicResolvedItemDto = components['schemas']['PublicResolvedItemDto'];
+export type PublicResolvedSubFieldDto = components['schemas']['PublicResolvedSubFieldDto'];
+export type PublicSeoMetadataDto = components['schemas']['PublicSeoMetadataDto'];
+export type PublicSitemapEntryDto = components['schemas']['PublicSitemapEntryDto'];
+export type PublicSitemapResponseDto = components['schemas']['PublicSitemapResponseDto'];
+export type PublicSitemapSeoDto = components['schemas']['PublicSitemapSeoDto'];
+export type PublicVendureAssetDescriptionDto = components['schemas']['PublicVendureAssetDescriptionDto'];
+export type PublicVendureAssetDescriptionsLookupResponseDto = components['schemas']['PublicVendureAssetDescriptionsLookupResponseDto'];
+export type SubmitFormDto = components['schemas']['SubmitFormDto'];
+export type $defs = Record<string, never>;
+export interface operations {
+    AssetsController_lookupAssets: {
+        parameters: {
+            query: {
+                /** @description Comma-separated asset UUIDs (max 50) */
+                ids: string;
+            };
+            header: {
+                /** @description Channel ID */
+                "x-channel-id": string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Public asset details */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PublicAssetListResponseDto"];
+                };
+            };
+        };
+    };
+    ChannelsController_findByCode: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                code: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Channel details with custom fields. For a renamed store's OLD code, still in its window: the store under its CURRENT code, with `previous_code`, `renamed_at` and `previous_code_until`, and the headers below. */
+            200: {
+                headers: {
+                    /** @description Old code only (RFC 9745): `@<unix seconds>` of the rename. The old code is deprecated; configure `code`. */
+                    Deprecation?: string;
+                    /** @description Old code only (RFC 8288): `<./{code}>; rel="successor-version"`, the lookup under the current code, relative to this one. */
+                    Link?: string;
+                    /** @description Old code only (RFC 8594): when the old code stops answering. */
+                    Sunset?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PublicChannelResponseDto"];
+                };
+            };
+            /** @description Channel not found: an unknown code, or an old code past its window, of a closed or deleted store, or of an organization hub. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    CollectionsController_findAll: {
+        parameters: {
+            query?: {
+                limit?: number;
+                /** @description Keyset cursor from the `next_cursor` of a previous response. Only `after` switches this list to a cursor page ordered by (created_at DESC, id DESC), to the millisecond — send it empty to start the sequence, and `limit` then sizes that page. This list is otherwise returned whole. */
+                after?: string;
+            };
+            header: {
+                /** @description Channel ID */
+                "x-channel-id": string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description List of collections */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PublicCollectionListResponseDto"];
+                };
+            };
+        };
+    };
+    CollectionsController_findOne: {
+        parameters: {
+            query?: never;
+            header: {
+                /** @description Channel ID */
+                "x-channel-id": string;
+            };
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Collection details */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PublicCollectionResponseDto"];
+                };
+            };
+            /** @description Collection not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    CollectionsController_findItems: {
+        parameters: {
+            query?: {
+                /** @description Filter by parent item ID ("root" for top-level) */
+                parent_id?: string;
+                /** @description Filter by exact item slug */
+                slug?: string;
+                /** @description Full-text search across item field values (Meilisearch). */
+                search?: string;
+                /** @description Sort order (e.g. "position", "-position") */
+                sort?: string;
+                /** @description Language code for locale-aware value merging */
+                language_code?: string;
+                limit?: number;
+                offset?: number;
+                /** @description Keyset cursor from the `next_cursor` of a previous response. Sending it — or `limit` without `offset`, up to 200 — switches the endpoint to a cursor page ordered by (created_at DESC, id DESC), to the millisecond. */
+                after?: string;
+                status?: "draft" | "published" | "archived";
+            };
+            header: {
+                /** @description Channel ID */
+                "x-channel-id": string;
+            };
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description List of items */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PublicCollectionItemListResponseDto"];
+                };
+            };
+        };
+    };
+    CollectionsController_findItem: {
+        parameters: {
+            query?: {
+                /** @description Language code for locale-aware value merging */
+                language_code?: string;
+            };
+            header: {
+                /** @description Channel ID */
+                "x-channel-id": string;
+            };
+            path: {
+                id: string;
+                itemId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Item details */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PublicCollectionItemResponseDto"];
+                };
+            };
+            /** @description Item not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    CollectionsController_getPageValues: {
+        parameters: {
+            query?: {
+                /** @description Language code for locale-aware value merging */
+                language_code?: string;
+            };
+            header: {
+                /** @description Channel ID */
+                "x-channel-id": string;
+            };
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Page values with field definitions */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PublicCollectionPageValuesResponseDto"];
+                };
+            };
+            /** @description Collection not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    ContentStringsController_findAll: {
+        parameters: {
+            query?: {
+                search?: string;
+                limit?: number;
+                offset?: number;
+                /** @description Keyset cursor from the `next_cursor` of a previous response. Only `after` switches this list to a cursor page ordered by (created_at DESC, id DESC), to the millisecond — send it empty to start the sequence, and `limit` then sizes that page. This list is otherwise ordered by key. */
+                after?: string;
+            };
+            header: {
+                /** @description Channel ID */
+                "x-channel-id": string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description List of content strings */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PublicContentStringListResponseDto"];
+                };
+            };
+        };
+    };
+    ContentStringsController_export: {
+        parameters: {
+            query?: never;
+            header: {
+                /** @description Channel ID */
+                "x-channel-id": string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Exported content strings */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        [key: string]: {
+                            [key: string]: string;
+                        };
+                    };
+                };
+            };
+        };
+    };
+    ContentStringsController_findOne: {
+        parameters: {
+            query?: never;
+            header: {
+                /** @description Channel ID */
+                "x-channel-id": string;
+            };
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Content string details */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PublicContentStringResponseDto"];
+                };
+            };
+            /** @description Not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    FormsController_findAll: {
+        parameters: {
+            query: {
+                limit?: number;
+                offset?: number;
+                search?: string;
+                sort?: string;
+                locale: string;
+                /** @description Keyset cursor from the `next_cursor` of a previous response. Sending it — or `limit` without `offset`, up to 200 — switches the endpoint to a cursor page ordered by (created_at DESC, id DESC), to the millisecond. */
+                after?: string;
+            };
+            header: {
+                /** @description Channel ID */
+                "x-channel-id": string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description List of forms */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PublicFormListResponseDto"];
+                };
+            };
+        };
+    };
+    FormsController_findBySlug: {
+        parameters: {
+            query: {
+                locale: string;
+            };
+            header: {
+                /** @description Channel ID */
+                "x-channel-id": string;
+            };
+            path: {
+                slug: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Form details with fields */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PublicFormResponseDto"];
+                };
+            };
+            /** @description Form not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    FormsController_fieldTypes: {
+        parameters: {
+            query?: never;
+            header: {
+                /** @description Channel ID */
+                "x-channel-id": string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Field-type registry */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PublicFormFieldTypesResponseDto"];
+                };
+            };
+        };
+    };
+    FormsController_findOne: {
+        parameters: {
+            query: {
+                locale: string;
+            };
+            header: {
+                /** @description Channel ID */
+                "x-channel-id": string;
+            };
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Form details with fields */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PublicFormResponseDto"];
+                };
+            };
+            /** @description Form not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    FormsController_submit: {
+        parameters: {
+            query?: never;
+            header: {
+                /** @description Channel ID */
+                "x-channel-id": string;
+            };
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["SubmitFormDto"];
+            };
+        };
+        responses: {
+            /** @description Form submitted */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PublicFormSubmissionResponseDto"];
+                };
+            };
+            /** @description Validation error */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    ItemsController_lookup: {
+        parameters: {
+            query: {
+                /** @description Comma-separated item UUIDs */
+                ids: string;
+            };
+            header: {
+                /** @description Channel ID */
+                "x-channel-id": string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Items with display metadata */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PublicItemLookupResponseDto"];
+                };
+            };
+        };
+    };
+    ItemsController_lookupWithFields: {
+        parameters: {
+            query: {
+                /** @description Comma-separated item UUIDs */
+                ids: string;
+                /** @description Comma-separated field slugs */
+                field_slugs: string;
+            };
+            header: {
+                /** @description Channel ID */
+                "x-channel-id": string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Items with display metadata and field values */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PublicItemLookupWithFieldsResponseDto"];
+                };
+            };
+        };
+    };
+    MenusController_findAll: {
+        parameters: {
+            query?: {
+                limit?: number;
+                offset?: number;
+                search?: string;
+                sort?: string;
+                /** @description Keyset cursor from the `next_cursor` of a previous response. Sending it — or `limit` without `offset`, up to 200 — switches the endpoint to a cursor page ordered by (created_at DESC, id DESC), to the millisecond. */
+                after?: string;
+            };
+            header: {
+                /** @description Channel ID */
+                "x-channel-id": string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description List of menus */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PublicMenuListResponseDto"];
+                };
+            };
+        };
+    };
+    MenusController_findBySlug: {
+        parameters: {
+            query?: never;
+            header: {
+                /** @description Channel ID */
+                "x-channel-id": string;
+            };
+            path: {
+                slug: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Menu details with items */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PublicMenuResponseDto"];
+                };
+            };
+            /** @description Menu not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    MenusController_findOne: {
+        parameters: {
+            query?: never;
+            header: {
+                /** @description Channel ID */
+                "x-channel-id": string;
+            };
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Menu details with items */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PublicMenuResponseDto"];
+                };
+            };
+            /** @description Menu not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    AssetsController_findPublicAssetById: {
+        parameters: {
+            query?: never;
+            header: {
+                /** @description Channel ID */
+                "x-channel-id": string;
+            };
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Public asset details */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PublicAssetResponseDto"];
+                };
+            };
+            /** @description Asset not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    ResolveController_resolve: {
+        parameters: {
+            query: {
+                /** @description URL path to resolve */
+                path: string;
+                /** @description Language code for localized values (e.g. en, nl) */
+                locale?: string;
+                /** @description Item status filter (default: published). Honoured only for a caller holding ReadCmsContent on the channel; every other caller gets published content. */
+                status?: string;
+            };
+            header: {
+                /** @description Channel ID */
+                "x-channel-id": string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Resolved content item with values and metadata */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PublicResolveResponseDto"];
+                };
+            };
+            /** @description No content found at the given path */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    SearchController_searchCollectionItems: {
+        parameters: {
+            query: {
+                q: string;
+                collection_id?: string;
+                collection_slug?: string;
+                status?: string;
+                parent_id?: string;
+                limit?: number;
+                offset?: number;
+                sort?: string;
+            };
+            header: {
+                /** @description Channel ID */
+                "x-channel-id": string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Search results */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PublicCollectionItemSearchResponseDto"];
+                };
+            };
+        };
+    };
+    ResolveController_sitemap: {
+        parameters: {
+            query: {
+                /** @description Language code for translated paths */
+                language_code?: string;
+                include_seo: string;
+            };
+            header: {
+                /** @description Channel ID */
+                "x-channel-id": string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description List of routable paths */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PublicSitemapResponseDto"];
+                };
+            };
+        };
+    };
+    AssetsController_lookupVendureAssetDescriptions: {
+        parameters: {
+            query: {
+                /** @description Comma-separated Vendure asset IDs (max 50) */
+                ids: string;
+            };
+            header: {
+                /** @description Channel ID */
+                "x-channel-id": string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Translations grouped by Vendure asset ID */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PublicVendureAssetDescriptionsLookupResponseDto"];
+                };
+            };
+        };
+    };
+}
+//# sourceMappingURL=cms.d.ts.map