@minipim/sdk 0.5.0 → 0.7.0

package/dist/openapi.d.ts

@@ -166,6 +166,7 @@ interface paths {
                             default_locale?: string;
                             default_channel?: string;
                             default_currency?: string;
+                            content_pages_enabled?: boolean;
                         };
                         initialAdmin?: {
                             /** Format: email */
@@ -258,7 +259,10 @@ interface paths {
             path?: never;
             cookie?: never;
         };
-        /** Get the current tenant organization */
+        /**
+         * Get the current tenant organization
+         * @description Includes `features`, the resolved state of optional features for this org. `entitled` is the plan-level answer; `enabled` is the org’s own preference. A feature is usable only when both are true.
+         */
         get: {
             parameters: {
                 query?: never;
@@ -286,6 +290,12 @@ interface paths {
                             createdAt: string;
                             /** Format: date-time */
                             updatedAt: string;
+                            features: {
+                                content_pages: {
+                                    entitled: boolean;
+                                    enabled: boolean;
+                                };
+                            };
                         };
                     };
                 };
@@ -328,6 +338,7 @@ interface paths {
                             default_locale?: string;
                             default_channel?: string;
                             default_currency?: string;
+                            content_pages_enabled?: boolean;
                         };
                     };
                 };
@@ -602,10 +613,15 @@ interface paths {
             path?: never;
             cookie?: never;
         };
-        /** List attributes */
+        /**
+         * List attributes
+         * @description Defaults to product attributes. Pass `entityKind=content` for content-page fields.
+         */
         get: {
             parameters: {
-                query?: never;
+                query?: {
+                    entityKind?: "product" | "content";
+                };
                 header?: never;
                 path?: never;
                 cookie?: never;
@@ -628,6 +644,8 @@ interface paths {
                             /** Format: date-time */
                             updatedAt: string;
                             code: string;
+                            /** @enum {string} */
+                            entityKind: "product" | "content";
                             label: (string | number | boolean | ("null" | null)) | unknown[] | {
                                 [key: string]: unknown;
                             };
@@ -669,6 +687,11 @@ interface paths {
                 content: {
                     "application/json": {
                         code: string;
+                        /**
+                         * @default product
+                         * @enum {string}
+                         */
+                        entityKind?: "product" | "content";
                         label: {
                             [key: string]: string;
                         };
@@ -710,6 +733,8 @@ interface paths {
                             /** Format: date-time */
                             updatedAt: string;
                             code: string;
+                            /** @enum {string} */
+                            entityKind: "product" | "content";
                             label: (string | number | boolean | ("null" | null)) | unknown[] | {
                                 [key: string]: unknown;
                             };
@@ -791,6 +816,8 @@ interface paths {
                             /** Format: date-time */
                             updatedAt: string;
                             code: string;
+                            /** @enum {string} */
+                            entityKind: "product" | "content";
                             label: (string | number | boolean | ("null" | null)) | unknown[] | {
                                 [key: string]: unknown;
                             };
@@ -928,6 +955,8 @@ interface paths {
                             /** Format: date-time */
                             updatedAt: string;
                             code: string;
+                            /** @enum {string} */
+                            entityKind: "product" | "content";
                             label: (string | number | boolean | ("null" | null)) | unknown[] | {
                                 [key: string]: unknown;
                             };
@@ -992,10 +1021,15 @@ interface paths {
             path?: never;
             cookie?: never;
         };
-        /** List attribute families */
+        /**
+         * List attribute families
+         * @description Defaults to product families. Pass `entityKind=content` for content-page types.
+         */
         get: {
             parameters: {
-                query?: never;
+                query?: {
+                    entityKind?: "product" | "content";
+                };
                 header?: never;
                 path?: never;
                 cookie?: never;
@@ -1018,6 +1052,8 @@ interface paths {
                             /** Format: date-time */
                             updatedAt: string;
                             code: string;
+                            /** @enum {string} */
+                            entityKind: "product" | "content";
                             label: (string | number | boolean | ("null" | null)) | unknown[] | {
                                 [key: string]: unknown;
                             };
@@ -1040,6 +1076,11 @@ interface paths {
                 content: {
                     "application/json": {
                         code: string;
+                        /**
+                         * @default product
+                         * @enum {string}
+                         */
+                        entityKind?: "product" | "content";
                         label: {
                             [key: string]: string;
                         };
@@ -1064,6 +1105,8 @@ interface paths {
                             /** Format: date-time */
                             updatedAt: string;
                             code: string;
+                            /** @enum {string} */
+                            entityKind: "product" | "content";
                             label: (string | number | boolean | ("null" | null)) | unknown[] | {
                                 [key: string]: unknown;
                             };
@@ -1129,6 +1172,8 @@ interface paths {
                             /** Format: date-time */
                             updatedAt: string;
                             code: string;
+                            /** @enum {string} */
+                            entityKind: "product" | "content";
                             label: (string | number | boolean | ("null" | null)) | unknown[] | {
                                 [key: string]: unknown;
                             };
@@ -1258,6 +1303,8 @@ interface paths {
                             /** Format: date-time */
                             updatedAt: string;
                             code: string;
+                            /** @enum {string} */
+                            entityKind: "product" | "content";
                             label: (string | number | boolean | ("null" | null)) | unknown[] | {
                                 [key: string]: unknown;
                             };
@@ -1523,6 +1570,7 @@ interface paths {
                     categoryId?: string;
                     includeDescendants?: boolean | ("true" | "false" | "1" | "0");
                     brand?: string;
+                    /** @description Repeatable — `?tag=a&tag=b` matches records carrying ALL listed tags. Values are canonicalized exactly as writes are, so `?tag=Buying%20Guide` matches the stored `buying-guide`; you never have to pre-slugify a filter. Backed by the GIN index on `tags`. */
                     tag?: string | string[];
                     connectorId?: string;
                     updatedSince?: string;
@@ -1569,6 +1617,7 @@ interface paths {
                                 attributes: (string | number | boolean | ("null" | null)) | unknown[] | {
                                     [key: string]: unknown;
                                 };
+                                /** @description Tags in canonical form. These are normalized on write (lower-cased, slugified, deduplicated, truncated), so this array will not necessarily match what was submitted — see the `tags` field on the create/update request body for the exact rules. Filter with `?tag=` using either form. */
                                 tags: string[];
                                 /** Format: uuid */
                                 createdBy: string | null;
@@ -1579,7 +1628,7 @@ interface paths {
                             }[];
                             limit: number;
                             offset: number;
-                            hasMore?: boolean;
+                            hasMore: boolean;
                             total?: number;
                         };
                     };
@@ -1618,7 +1667,10 @@ interface paths {
                                 value?: unknown;
                             }[];
                         };
-                        /** @default [] */
+                        /**
+                         * @description Free-form tags, canonicalized on write and echoed back in canonical form — the response will NOT match your input verbatim. Each tag is lower-cased, stripped of diacritics, has every run of non-alphanumerics replaced with `-`, is trimmed of leading/trailing `-`, and is then truncated to 60 characters. So `"Buying Guide"` is stored and filtered as `buying-guide`. Tags that normalize to nothing (`""`, `"!!"`) are dropped, and duplicates are removed keeping first-occurrence order, so the array you get back may be SHORTER than the one you sent. Note the asymmetry with `maxLength`: an item may be up to 80 characters on input but is truncated to 60 once canonicalized, which can collapse two long tags into one.
+                         * @default []
+                         */
                         tags?: string[];
                     };
                 };
@@ -1648,6 +1700,7 @@ interface paths {
                             attributes: (string | number | boolean | ("null" | null)) | unknown[] | {
                                 [key: string]: unknown;
                             };
+                            /** @description Tags in canonical form. These are normalized on write (lower-cased, slugified, deduplicated, truncated), so this array will not necessarily match what was submitted — see the `tags` field on the create/update request body for the exact rules. Filter with `?tag=` using either form. */
                             tags: string[];
                             /** Format: uuid */
                             createdBy: string | null;
@@ -1714,6 +1767,7 @@ interface paths {
                     categoryId?: string;
                     includeDescendants?: boolean | ("true" | "false" | "1" | "0");
                     brand?: string;
+                    /** @description Repeatable — `?tag=a&tag=b` matches records carrying ALL listed tags. Values are canonicalized exactly as writes are, so `?tag=Buying%20Guide` matches the stored `buying-guide`; you never have to pre-slugify a filter. Backed by the GIN index on `tags`. */
                     tag?: string | string[];
                     connectorId?: string;
                     updatedSince?: string;
@@ -1933,6 +1987,7 @@ interface paths {
                             attributes: (string | number | boolean | ("null" | null)) | unknown[] | {
                                 [key: string]: unknown;
                             };
+                            /** @description Tags in canonical form. These are normalized on write (lower-cased, slugified, deduplicated, truncated), so this array will not necessarily match what was submitted — see the `tags` field on the create/update request body for the exact rules. Filter with `?tag=` using either form. */
                             tags: string[];
                             /** Format: uuid */
                             createdBy: string | null;
@@ -2056,6 +2111,7 @@ interface paths {
                                 value?: unknown;
                             }[];
                         };
+                        /** @description Replaces the full tag list when present. Free-form tags, canonicalized on write and echoed back in canonical form — the response will NOT match your input verbatim. Each tag is lower-cased, stripped of diacritics, has every run of non-alphanumerics replaced with `-`, is trimmed of leading/trailing `-`, and is then truncated to 60 characters. So `"Buying Guide"` is stored and filtered as `buying-guide`. Tags that normalize to nothing (`""`, `"!!"`) are dropped, and duplicates are removed keeping first-occurrence order, so the array you get back may be SHORTER than the one you sent. Note the asymmetry with `maxLength`: an item may be up to 80 characters on input but is truncated to 60 once canonicalized, which can collapse two long tags into one. */
                         tags?: string[];
                     };
                 };
@@ -2085,6 +2141,7 @@ interface paths {
                             attributes: (string | number | boolean | ("null" | null)) | unknown[] | {
                                 [key: string]: unknown;
                             };
+                            /** @description Tags in canonical form. These are normalized on write (lower-cased, slugified, deduplicated, truncated), so this array will not necessarily match what was submitted — see the `tags` field on the create/update request body for the exact rules. Filter with `?tag=` using either form. */
                             tags: string[];
                             /** Format: uuid */
                             createdBy: string | null;
@@ -2252,6 +2309,7 @@ interface paths {
                             attributes: (string | number | boolean | ("null" | null)) | unknown[] | {
                                 [key: string]: unknown;
                             };
+                            /** @description Tags in canonical form. These are normalized on write (lower-cased, slugified, deduplicated, truncated), so this array will not necessarily match what was submitted — see the `tags` field on the create/update request body for the exact rules. Filter with `?tag=` using either form. */
                             tags: string[];
                             /** Format: uuid */
                             createdBy: string | null;
@@ -2658,6 +2716,7 @@ interface paths {
                         productIds: string[];
                         /** @enum {string} */
                         mode: "add" | "remove" | "replace";
+                        /** @description Free-form tags, canonicalized on write and echoed back in canonical form — the response will NOT match your input verbatim. Each tag is lower-cased, stripped of diacritics, has every run of non-alphanumerics replaced with `-`, is trimmed of leading/trailing `-`, and is then truncated to 60 characters. So `"Buying Guide"` is stored and filtered as `buying-guide`. Tags that normalize to nothing (`""`, `"!!"`) are dropped, and duplicates are removed keeping first-occurrence order, so the array you get back may be SHORTER than the one you sent. Note the asymmetry with `maxLength`: an item may be up to 80 characters on input but is truncated to 60 once canonicalized, which can collapse two long tags into one. */
                         tags: string[];
                     };
                 };
@@ -3303,16 +3362,677 @@ interface paths {
                             /** Format: date-time */
                             updatedAt: string;
                             /** Format: uuid */
-                            variantId: string;
+                            variantId: string;
+                            /** @enum {string} */
+                            type: "sku" | "upc" | "gtin8" | "gtin12" | "gtin13" | "gtin14" | "ean" | "mpn" | "asin" | "isbn" | "custom";
+                            customLabel: string | null;
+                            value: string;
+                        }[];
+                    };
+                };
+                /** @description Default Response */
+                422: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: {
+                                code: string;
+                                message: string;
+                                details?: unknown;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        /**
+         * Attach an identifier (SKU/UPC/GTIN/etc.) to a variant
+         * @description GTIN-typed values are validated by check digit and length on write.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    variantId: string;
+                };
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": {
+                        /** @enum {string} */
+                        type: "sku" | "upc" | "gtin8" | "gtin12" | "gtin13" | "gtin14" | "ean" | "mpn" | "asin" | "isbn" | "custom";
+                        customLabel?: string;
+                        value: string;
+                    };
+                };
+            };
+            responses: {
+                /** @description Default Response */
+                201: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            /** Format: uuid */
+                            id: string;
+                            /** Format: uuid */
+                            organizationId: string;
+                            /** Format: date-time */
+                            createdAt: string;
+                            /** Format: date-time */
+                            updatedAt: string;
+                            /** Format: uuid */
+                            variantId: string;
+                            /** @enum {string} */
+                            type: "sku" | "upc" | "gtin8" | "gtin12" | "gtin13" | "gtin14" | "ean" | "mpn" | "asin" | "isbn" | "custom";
+                            customLabel: string | null;
+                            value: string;
+                        };
+                    };
+                };
+                /** @description Default Response */
+                422: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: {
+                                code: string;
+                                message: string;
+                                details?: unknown;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/identifiers/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post?: never;
+        /** Detach an identifier */
+        delete: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Default Response */
+                204: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": "null" | null;
+                    };
+                };
+                /** @description Default Response */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: {
+                                code: string;
+                                message: string;
+                                details?: unknown;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/content": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List content pages
+         * @description Filters and pagination mirror `GET /v1/products`. `tag` is repeatable and matches pages carrying ALL listed tags.
+         */
+        get: {
+            parameters: {
+                query?: {
+                    status?: "draft" | "active" | "archived";
+                    q?: string;
+                    familyId?: string;
+                    categoryId?: string;
+                    channelId?: string;
+                    /** @description Repeatable — `?tag=a&tag=b` matches records carrying ALL listed tags. Values are canonicalized exactly as writes are, so `?tag=Buying%20Guide` matches the stored `buying-guide`; you never have to pre-slugify a filter. */
+                    tag?: string | string[];
+                    updatedSince?: string;
+                    limit?: number;
+                    offset?: number;
+                };
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Default Response */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            data: {
+                                /** Format: uuid */
+                                id: string;
+                                /** Format: uuid */
+                                organizationId: string;
+                                /** Format: date-time */
+                                createdAt: string;
+                                /** Format: date-time */
+                                updatedAt: string;
+                                /** Format: uuid */
+                                familyId: string;
+                                title: string;
+                                slug: string;
+                                /** @enum {string} */
+                                status: "draft" | "active" | "archived";
+                                /** Format: date-time */
+                                publishedAt: string | null;
+                                /** Format: uuid */
+                                channelId: string | null;
+                                attributes: (string | number | boolean | ("null" | null)) | unknown[] | {
+                                    [key: string]: unknown;
+                                };
+                                /** @description Tags in canonical form. These are normalized on write (lower-cased, slugified, deduplicated, truncated), so this array will not necessarily match what was submitted — see the `tags` field on the create/update request body for the exact rules. Filter with `?tag=` using either form. */
+                                tags: string[];
+                                /** Format: uuid */
+                                createdBy: string | null;
+                                /** Format: uuid */
+                                updatedBy: string | null;
+                            }[];
+                            limit: number;
+                            offset: number;
+                            hasMore: boolean;
+                        };
+                    };
+                };
+                /** @description Default Response */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: {
+                                code: string;
+                                message: string;
+                                details?: unknown;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        put?: never;
+        /**
+         * Create a content page
+         * @description Validates `attributes` against the family at write time, exactly as products do — an undeclared attribute code is a 422. Required attributes are enforced only for `active` pages, so a draft may be saved incomplete. Emits `content_page.created`.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": {
+                        /** Format: uuid */
+                        familyId: string;
+                        title: string;
+                        slug?: string;
+                        /**
+                         * @default draft
+                         * @enum {string}
+                         */
+                        status?: "draft" | "active" | "archived";
+                        /** Format: date-time */
+                        publishedAt?: string;
+                        /** Format: uuid */
+                        channelId?: string | null;
+                        /** @default {} */
+                        attributes?: {
+                            [key: string]: {
+                                locale: string | null;
+                                channel: string | null;
+                                value?: unknown;
+                            }[];
+                        };
+                        /**
+                         * @description Free-form tags, canonicalized on write and echoed back in canonical form — the response will NOT match your input verbatim. Each tag is lower-cased, stripped of diacritics, has every run of non-alphanumerics replaced with `-`, is trimmed of leading/trailing `-`, and is then truncated to 60 characters. So `"Buying Guide"` is stored and filtered as `buying-guide`. Tags that normalize to nothing (`""`, `"!!"`) are dropped, and duplicates are removed keeping first-occurrence order, so the array you get back may be SHORTER than the one you sent. Note the asymmetry with `maxLength`: an item may be up to 80 characters on input but is truncated to 60 once canonicalized, which can collapse two long tags into one.
+                         * @default []
+                         */
+                        tags?: string[];
+                    };
+                };
+            };
+            responses: {
+                /** @description Default Response */
+                201: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            /** Format: uuid */
+                            id: string;
+                            /** Format: uuid */
+                            organizationId: string;
+                            /** Format: date-time */
+                            createdAt: string;
+                            /** Format: date-time */
+                            updatedAt: string;
+                            /** Format: uuid */
+                            familyId: string;
+                            title: string;
+                            slug: string;
+                            /** @enum {string} */
+                            status: "draft" | "active" | "archived";
+                            /** Format: date-time */
+                            publishedAt: string | null;
+                            /** Format: uuid */
+                            channelId: string | null;
+                            attributes: (string | number | boolean | ("null" | null)) | unknown[] | {
+                                [key: string]: unknown;
+                            };
+                            /** @description Tags in canonical form. These are normalized on write (lower-cased, slugified, deduplicated, truncated), so this array will not necessarily match what was submitted — see the `tags` field on the create/update request body for the exact rules. Filter with `?tag=` using either form. */
+                            tags: string[];
+                            /** Format: uuid */
+                            createdBy: string | null;
+                            /** Format: uuid */
+                            updatedBy: string | null;
+                        };
+                    };
+                };
+                /** @description Default Response */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: {
+                                code: string;
+                                message: string;
+                                details?: unknown;
+                            };
+                        };
+                    };
+                };
+                /** @description Default Response */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: {
+                                code: string;
+                                message: string;
+                                details?: unknown;
+                            };
+                        };
+                    };
+                };
+                /** @description Default Response */
+                409: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: {
+                                code: string;
+                                message: string;
+                                details?: unknown;
+                            };
+                        };
+                    };
+                };
+                /** @description Default Response */
+                422: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: {
+                                code: string;
+                                message: string;
+                                details?: unknown;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/content/tags": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List all content-page tags in use, with counts
+         * @description Every distinct tag currently on at least one content page, ordered by usage. Powers tag autocomplete in the editor, which is what keeps a vocabulary from drifting into `guide` / `guides` / `Guides`. Filter pages by tag with `GET /v1/content?tag=<tag>` (repeatable; multiple tags AND together).
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Default Response */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            value: string;
+                            count: number;
+                        }[];
+                    };
+                };
+                /** @description Default Response */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: {
+                                code: string;
+                                message: string;
+                                details?: unknown;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/content/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get a content page */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Default Response */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            /** Format: uuid */
+                            id: string;
+                            /** Format: uuid */
+                            organizationId: string;
+                            /** Format: date-time */
+                            createdAt: string;
+                            /** Format: date-time */
+                            updatedAt: string;
+                            /** Format: uuid */
+                            familyId: string;
+                            title: string;
+                            slug: string;
+                            /** @enum {string} */
+                            status: "draft" | "active" | "archived";
+                            /** Format: date-time */
+                            publishedAt: string | null;
+                            /** Format: uuid */
+                            channelId: string | null;
+                            attributes: (string | number | boolean | ("null" | null)) | unknown[] | {
+                                [key: string]: unknown;
+                            };
+                            /** @description Tags in canonical form. These are normalized on write (lower-cased, slugified, deduplicated, truncated), so this array will not necessarily match what was submitted — see the `tags` field on the create/update request body for the exact rules. Filter with `?tag=` using either form. */
+                            tags: string[];
+                            /** Format: uuid */
+                            createdBy: string | null;
+                            /** Format: uuid */
+                            updatedBy: string | null;
+                            categoryIds: string[];
+                        };
+                    };
+                };
+                /** @description Default Response */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: {
+                                code: string;
+                                message: string;
+                                details?: unknown;
+                            };
+                        };
+                    };
+                };
+                /** @description Default Response */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: {
+                                code: string;
+                                message: string;
+                                details?: unknown;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        /**
+         * Delete a content page
+         * @description Emits `content_page.deleted`.
+         */
+        delete: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Default Response */
+                204: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": "null" | null;
+                    };
+                };
+                /** @description Default Response */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: {
+                                code: string;
+                                message: string;
+                                details?: unknown;
+                            };
+                        };
+                    };
+                };
+                /** @description Default Response */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: {
+                                code: string;
+                                message: string;
+                                details?: unknown;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        options?: never;
+        head?: never;
+        /**
+         * Update a content page
+         * @description `attributes` is merged per code, not replaced wholesale. Stamps `publishedAt` on the first transition to `active` unless the caller supplies one. Emits `content_page.updated` carrying `previous_status`.
+         */
+        patch: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    id: string;
+                };
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": {
+                        title?: string;
+                        slug?: string;
+                        /** @enum {string} */
+                        status?: "draft" | "active" | "archived";
+                        /** Format: date-time */
+                        publishedAt?: string | null;
+                        /** Format: uuid */
+                        channelId?: string | null;
+                        attributes?: {
+                            [key: string]: {
+                                locale: string | null;
+                                channel: string | null;
+                                value?: unknown;
+                            }[];
+                        };
+                        /** @description Replaces the full tag list when present. Free-form tags, canonicalized on write and echoed back in canonical form — the response will NOT match your input verbatim. Each tag is lower-cased, stripped of diacritics, has every run of non-alphanumerics replaced with `-`, is trimmed of leading/trailing `-`, and is then truncated to 60 characters. So `"Buying Guide"` is stored and filtered as `buying-guide`. Tags that normalize to nothing (`""`, `"!!"`) are dropped, and duplicates are removed keeping first-occurrence order, so the array you get back may be SHORTER than the one you sent. Note the asymmetry with `maxLength`: an item may be up to 80 characters on input but is truncated to 60 once canonicalized, which can collapse two long tags into one. */
+                        tags?: string[];
+                    };
+                };
+            };
+            responses: {
+                /** @description Default Response */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            /** Format: uuid */
+                            id: string;
+                            /** Format: uuid */
+                            organizationId: string;
+                            /** Format: date-time */
+                            createdAt: string;
+                            /** Format: date-time */
+                            updatedAt: string;
+                            /** Format: uuid */
+                            familyId: string;
+                            title: string;
+                            slug: string;
                             /** @enum {string} */
-                            type: "sku" | "upc" | "gtin8" | "gtin12" | "gtin13" | "gtin14" | "ean" | "mpn" | "asin" | "isbn" | "custom";
-                            customLabel: string | null;
-                            value: string;
-                        }[];
+                            status: "draft" | "active" | "archived";
+                            /** Format: date-time */
+                            publishedAt: string | null;
+                            /** Format: uuid */
+                            channelId: string | null;
+                            attributes: (string | number | boolean | ("null" | null)) | unknown[] | {
+                                [key: string]: unknown;
+                            };
+                            /** @description Tags in canonical form. These are normalized on write (lower-cased, slugified, deduplicated, truncated), so this array will not necessarily match what was submitted — see the `tags` field on the create/update request body for the exact rules. Filter with `?tag=` using either form. */
+                            tags: string[];
+                            /** Format: uuid */
+                            createdBy: string | null;
+                            /** Format: uuid */
+                            updatedBy: string | null;
+                        };
                     };
                 };
                 /** @description Default Response */
-                422: {
+                403: {
                     headers: {
                         [name: string]: unknown;
                     };
@@ -3326,53 +4046,33 @@ interface paths {
                         };
                     };
                 };
-            };
-        };
-        /**
-         * Attach an identifier (SKU/UPC/GTIN/etc.) to a variant
-         * @description GTIN-typed values are validated by check digit and length on write.
-         */
-        post: {
-            parameters: {
-                query?: never;
-                header?: never;
-                path: {
-                    variantId: string;
-                };
-                cookie?: never;
-            };
-            requestBody: {
-                content: {
-                    "application/json": {
-                        /** @enum {string} */
-                        type: "sku" | "upc" | "gtin8" | "gtin12" | "gtin13" | "gtin14" | "ean" | "mpn" | "asin" | "isbn" | "custom";
-                        customLabel?: string;
-                        value: string;
+                /** @description Default Response */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: {
+                                code: string;
+                                message: string;
+                                details?: unknown;
+                            };
+                        };
                     };
                 };
-            };
-            responses: {
                 /** @description Default Response */
-                201: {
+                409: {
                     headers: {
                         [name: string]: unknown;
                     };
                     content: {
                         "application/json": {
-                            /** Format: uuid */
-                            id: string;
-                            /** Format: uuid */
-                            organizationId: string;
-                            /** Format: date-time */
-                            createdAt: string;
-                            /** Format: date-time */
-                            updatedAt: string;
-                            /** Format: uuid */
-                            variantId: string;
-                            /** @enum {string} */
-                            type: "sku" | "upc" | "gtin8" | "gtin12" | "gtin13" | "gtin14" | "ean" | "mpn" | "asin" | "isbn" | "custom";
-                            customLabel: string | null;
-                            value: string;
+                            error: {
+                                code: string;
+                                message: string;
+                                details?: unknown;
+                            };
                         };
                     };
                 };
@@ -3393,13 +4093,9 @@ interface paths {
                 };
             };
         };
-        delete?: never;
-        options?: never;
-        head?: never;
-        patch?: never;
         trace?: never;
     };
-    "/v1/identifiers/{id}": {
+    "/v1/content/{id}/categories": {
         parameters: {
             query?: never;
             header?: never;
@@ -3407,10 +4103,11 @@ interface paths {
             cookie?: never;
         };
         get?: never;
-        put?: never;
-        post?: never;
-        /** Detach an identifier */
-        delete: {
+        /**
+         * Replace a content page’s categories
+         * @description Replaces the full set — pass an empty array to clear. Uses the same `categories` table products do, so a category means one thing across the whole org.
+         */
+        put: {
             parameters: {
                 query?: never;
                 header?: never;
@@ -3419,15 +4116,44 @@ interface paths {
                 };
                 cookie?: never;
             };
-            requestBody?: never;
+            requestBody: {
+                content: {
+                    "application/json": {
+                        categoryIds: string[];
+                    };
+                };
+            };
             responses: {
                 /** @description Default Response */
-                204: {
+                200: {
                     headers: {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": "null" | null;
+                        "application/json": {
+                            data: {
+                                /** Format: uuid */
+                                contentPageId: string;
+                                /** Format: uuid */
+                                categoryId: string;
+                                position: number;
+                            }[];
+                        };
+                    };
+                };
+                /** @description Default Response */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: {
+                                code: string;
+                                message: string;
+                                details?: unknown;
+                            };
+                        };
                     };
                 };
                 /** @description Default Response */
@@ -3447,6 +4173,8 @@ interface paths {
                 };
             };
         };
+        post?: never;
+        delete?: never;
         options?: never;
         head?: never;
         patch?: never;
@@ -4992,7 +5720,110 @@ interface paths {
                                     /** Format: uuid */
                                     mediaId: string;
                                     /** @enum {string} */
-                                    entityType: "product" | "variant";
+                                    entityType: "product" | "variant" | "content_page";
+                                    /** Format: uuid */
+                                    entityId: string;
+                                    /** @enum {string} */
+                                    role: "hero" | "gallery" | "thumbnail" | "technical" | "lifestyle" | "swatch";
+                                    position: number;
+                                    altText: ((string | number | boolean | ("null" | null)) | unknown[] | {
+                                        [key: string]: unknown;
+                                    }) | null;
+                                    /** Format: uuid */
+                                    channelId: string | null;
+                                };
+                                url: string | null;
+                            }[];
+                        };
+                    };
+                };
+                /** @description Default Response */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: {
+                                code: string;
+                                message: string;
+                                details?: unknown;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/content/{id}/media": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List media attached to a content page
+         * @description Same shape as the product/variant galleries. Lives here rather than under /v1/content so it sits with its siblings and reuses the same URL resolution; associations are tenant-scoped by RLS regardless.
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Default Response */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            data: {
+                                /** Format: uuid */
+                                id: string;
+                                /** Format: uuid */
+                                organizationId: string;
+                                /** Format: date-time */
+                                createdAt: string;
+                                /** Format: date-time */
+                                updatedAt: string;
+                                /** @enum {string} */
+                                type: "image" | "video" | "document" | "model_3d";
+                                storageKey: string;
+                                filename: string;
+                                mimeType: string;
+                                sizeBytes: number;
+                                width: number | null;
+                                height: number | null;
+                                metadata: ((string | number | boolean | ("null" | null)) | unknown[] | {
+                                    [key: string]: unknown;
+                                }) | null;
+                                association: {
+                                    /** Format: uuid */
+                                    id: string;
+                                    /** Format: uuid */
+                                    organizationId: string;
+                                    /** Format: date-time */
+                                    createdAt: string;
+                                    /** Format: date-time */
+                                    updatedAt: string;
+                                    /** Format: uuid */
+                                    mediaId: string;
+                                    /** @enum {string} */
+                                    entityType: "product" | "variant" | "content_page";
                                     /** Format: uuid */
                                     entityId: string;
                                     /** @enum {string} */
@@ -5092,7 +5923,7 @@ interface paths {
                                     /** Format: uuid */
                                     mediaId: string;
                                     /** @enum {string} */
-                                    entityType: "product" | "variant";
+                                    entityType: "product" | "variant" | "content_page";
                                     /** Format: uuid */
                                     entityId: string;
                                     /** @enum {string} */
@@ -5154,7 +5985,40 @@ interface paths {
                 path?: never;
                 cookie?: never;
             };
-            requestBody?: never;
+            requestBody: {
+                content: {
+                    "multipart/form-data": {
+                        /**
+                         * Format: binary
+                         * @description The file to upload. Images, video and PDF are accepted; see the 400 response for the rejected-mime and blocked-extension cases.
+                         */
+                        file: string;
+                        /**
+                         * @description Attach the upload in the same transaction. Requires `entityId`; supplying only one of the pair uploads the file WITHOUT associating it.
+                         * @enum {string}
+                         */
+                        entityType?: "product" | "variant" | "content_page";
+                        /**
+                         * Format: uuid
+                         * @description The id of the entity named by `entityType`.
+                         */
+                        entityId?: string;
+                        /**
+                         * @description Association role. Ignored unless `entityType`+`entityId` are present.
+                         * @default gallery
+                         * @enum {string}
+                         */
+                        role?: "hero" | "gallery" | "thumbnail" | "technical" | "lifestyle" | "swatch";
+                        /**
+                         * @description Sort position within the entity’s gallery.
+                         * @default 0
+                         */
+                        position?: number;
+                        /** @description A JSON OBJECT keyed by locale, sent as a STRING — e.g. `{"en_US":"Blue widget on white"}`. Unparseable JSON is ignored rather than rejected, so malformed alt text costs you the alt text, not the upload. */
+                        altText?: string;
+                    };
+                };
+            };
             responses: {
                 /** @description Default Response */
                 201: {
@@ -5194,7 +6058,7 @@ interface paths {
                                 /** Format: uuid */
                                 mediaId: string;
                                 /** @enum {string} */
-                                entityType: "product" | "variant";
+                                entityType: "product" | "variant" | "content_page";
                                 /** Format: uuid */
                                 entityId: string;
                                 /** @enum {string} */
@@ -5271,7 +6135,7 @@ interface paths {
                         /** Format: uuid */
                         mediaId: string;
                         /** @enum {string} */
-                        entityType: "product" | "variant";
+                        entityType: "product" | "variant" | "content_page";
                         /** Format: uuid */
                         entityId: string;
                         /**
@@ -5308,7 +6172,7 @@ interface paths {
                             /** Format: uuid */
                             mediaId: string;
                             /** @enum {string} */
-                            entityType: "product" | "variant";
+                            entityType: "product" | "variant" | "content_page";
                             /** Format: uuid */
                             entityId: string;
                             /** @enum {string} */
@@ -5436,7 +6300,7 @@ interface paths {
                             /** Format: uuid */
                             mediaId: string;
                             /** @enum {string} */
-                            entityType: "product" | "variant";
+                            entityType: "product" | "variant" | "content_page";
                             /** Format: uuid */
                             entityId: string;
                             /** @enum {string} */
@@ -5492,7 +6356,7 @@ interface paths {
                 content: {
                     "application/json": {
                         /** @enum {string} */
-                        entityType: "product" | "variant";
+                        entityType: "product" | "variant" | "content_page";
                         /** Format: uuid */
                         entityId: string;
                         orderedIds: string[];
@@ -5519,7 +6383,7 @@ interface paths {
                                 /** Format: uuid */
                                 mediaId: string;
                                 /** @enum {string} */
-                                entityType: "product" | "variant";
+                                entityType: "product" | "variant" | "content_page";
                                 /** Format: uuid */
                                 entityId: string;
                                 /** @enum {string} */
@@ -5598,7 +6462,7 @@ interface paths {
                                 /** Format: uuid */
                                 mediaId: string;
                                 /** @enum {string} */
-                                entityType: "product" | "variant";
+                                entityType: "product" | "variant" | "content_page";
                                 /** Format: uuid */
                                 entityId: string;
                                 /** @enum {string} */
@@ -6712,7 +7576,7 @@ interface paths {
                             availability: "oss" | "hosted";
                             capabilities: {
                                 /** @enum {string} */
-                                entity: "product" | "variant" | "media" | "category";
+                                entity: "product" | "variant" | "media" | "category" | "content_page";
                                 /** @enum {string} */
                                 direction: "push" | "pull" | "bidirectional";
                             }[];
@@ -8178,8 +9042,7 @@ interface paths {
                             }[];
                             limit: number;
                             offset: number;
-                            hasMore?: boolean;
-                            total?: number;
+                            hasMore: boolean;
                         };
                     };
                 };