@minipim/sdk 0.6.0 → 0.7.0

package/README.md

@@ -126,7 +126,11 @@ for await (const p of paginate<Product>(pim, '/v1/products', { query: { status:
 const all = await collectAll<Product>(pim, '/v1/products');
 ```
 
-`paginate` manages `limit`/`offset`, honors the server's `hasMore`, and defaults to the 200-row max page size (override with `pageSize`). Pass `withTotal: true` in `query` if you need `total` — it adds one `COUNT(*)`, so leave it off on hot reads.
+`paginate` manages `limit`/`offset`, honors the server's `hasMore`, and defaults to the 200-row max page size (override with `pageSize`).
+
+`withTotal: true` is supported by **`/v1/products` only** — it adds one `COUNT(*)`, so leave it off on hot reads. Other list endpoints never return `total`, and as of v0.7.0 their types say so rather than declaring a field that was always `undefined`.
+
+Against API **0.14.0 and newer, `hasMore` is present and exact on every list endpoint** — the server reads one row past the page, so a final page that happens to be exactly full reports `false` instead of sending you after an empty one. Older deployments omitted `hasMore` everywhere except `/v1/products`; `paginate` keeps a short-page fallback for those, which is the whole reason not to hand-roll the loop.
 
 Endpoints that return a **plain array** instead of the envelope (`/v1/categories` without `?limit=`, `/v1/attributes`, `/v1/products/{id}/variants`) are handled too (v0.3.0+): the array is treated as the one-and-only page, so `collectAll` works uniformly across every list endpoint.
 
@@ -167,6 +171,44 @@ await pim.GET('/v1/products', {
 
 Needs API **0.9.0+**. Check `GET /healthz`.
 
+## Tags
+
+Tags are **canonicalized on write**, so what you read back is not verbatim what you sent:
+
+```ts
+await pim.POST('/v1/content', { body: { /* … */ tags: ['Buying Guide', 'buying guide', 'FAQ!'] } });
+// stored, and returned as: ['buying-guide', 'faq']
+```
+
+Each tag is lower-cased, stripped of diacritics, has runs of non-alphanumerics collapsed to `-`, is trimmed of leading/trailing `-`, and is truncated to **60 characters**. Empties are dropped and duplicates removed (first occurrence wins), so **the array you get back can be shorter than the one you sent**. Note that the schema's `maxLength` is 80: two tags differing only past character 60 collapse into one.
+
+This is deliberate — it is what makes `Featured`, `featured` and `FEATURED` one tag rather than three. Filters are canonicalized identically, so you never have to pre-slugify one:
+
+```ts
+await pim.GET('/v1/content', { params: { query: { tag: 'Buying Guide' } } }); // matches buying-guide
+```
+
+`tag` is repeatable and ANDs: `{ tag: ['guide', 'seo'] }` returns only pages carrying both. `GET /v1/products/tags` and `GET /v1/content/tags` list the vocabulary actually in use, with counts — two **separate** vocabularies, since an editorial tag and a merchandising tag rarely mean the same thing.
+
+Documented in the field descriptions from API **0.14.1+**, and in these types from v0.7.0.
+
+## Uploading files
+
+`POST /v1/media` is `multipart/form-data`, not JSON. The file field is named `file`; everything else is optional and lets you attach the upload in the same request:
+
+```ts
+const form = new FormData();
+form.append('file', blob, 'sell-sheet.pdf');
+form.append('entityType', 'product');       // 'product' | 'variant' | 'content_page'
+form.append('entityId', productId);
+form.append('role', 'technical');           // hero | gallery | thumbnail | technical | lifestyle | swatch
+form.append('altText', JSON.stringify({ en_US: 'Sell sheet' })); // a JSON *string*, not an object
+```
+
+`altText` is parsed as JSON and parse failures are swallowed, so passing a real object silently stores no alt text. Send `JSON.stringify(...)`.
+
+Requires API **0.14.0+** to appear in the spec at all — before that this endpoint published no request body, so generated clients had nothing for it.
+
 ## Attribute helpers
 
 Attribute values are `unknown` and keyed by `(locale, channel)`. List responses return the raw `{ code: [{ locale, channel, value }] }` shape (only product *detail* with `?locale=&channel=` returns a flat `resolvedAttributes`). The SDK ships the flatten + coercion helpers so you don't reimplement them:

package/dist/index.d.cts

@@ -78,12 +78,17 @@ declare function createMinipimClient(opts: CreateMinipimClientOptions): MinipimC
 
 /**
  * Generic pagination helper. MiniPim list endpoints return
- * `{ data, limit, offset }`, and **only `/v1/products` also returns
- * `hasMore`** — so this walks the pages by trusting `hasMore` when it is
- * present and falling back to a short-page check when it isn't. That is the
- * whole reason to use this instead of a hand-rolled `while (hasMore)` loop,
- * which reads exactly one page from every other endpoint and stops. Yields
- * one item at a time.
+ * `{ data, limit, offset, hasMore }`, where `hasMore` is always present and
+ * exact — the server fetches one row past the page to decide it, so a final
+ * page that is exactly full reports `false` instead of sending you after an
+ * empty one. Yields one item at a time.
+ *
+ * `hasMore` stays OPTIONAL in the type below, and the short-page fallback
+ * stays, deliberately: this client talks to whatever version the deployment is
+ * running, and API ≤ 0.13.0 omitted the field everywhere except
+ * `/v1/products`. Keeping the fallback means an older instance paginates
+ * correctly rather than reading one page and stopping — which is exactly the
+ * bug a hand-rolled `while (hasMore)` loop hit against those versions.
  *
  * Typed loosely on purpose — openapi-fetch's per-path generics don't
  * compose into a single reusable signature without a lot of conditional-

package/dist/index.d.ts

@@ -78,12 +78,17 @@ declare function createMinipimClient(opts: CreateMinipimClientOptions): MinipimC
 
 /**
  * Generic pagination helper. MiniPim list endpoints return
- * `{ data, limit, offset }`, and **only `/v1/products` also returns
- * `hasMore`** — so this walks the pages by trusting `hasMore` when it is
- * present and falling back to a short-page check when it isn't. That is the
- * whole reason to use this instead of a hand-rolled `while (hasMore)` loop,
- * which reads exactly one page from every other endpoint and stops. Yields
- * one item at a time.
+ * `{ data, limit, offset, hasMore }`, where `hasMore` is always present and
+ * exact — the server fetches one row past the page to decide it, so a final
+ * page that is exactly full reports `false` instead of sending you after an
+ * empty one. Yields one item at a time.
+ *
+ * `hasMore` stays OPTIONAL in the type below, and the short-page fallback
+ * stays, deliberately: this client talks to whatever version the deployment is
+ * running, and API ≤ 0.13.0 omitted the field everywhere except
+ * `/v1/products`. Keeping the fallback means an older instance paginates
+ * correctly rather than reading one page and stopping — which is exactly the
+ * bug a hand-rolled `while (hasMore)` loop hit against those versions.
  *
  * Typed loosely on purpose — openapi-fetch's per-path generics don't
  * compose into a single reusable signature without a lot of conditional-

package/dist/openapi.d.cts

@@ -914,11 +914,6 @@ interface paths {
                 content: {
                     "application/json": {
                         code?: string;
-                        /**
-                         * @default product
-                         * @enum {string}
-                         */
-                        entityKind?: "product" | "content";
                         label?: {
                             [key: string]: string;
                         };
@@ -1575,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;
@@ -1621,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;
@@ -1631,7 +1628,7 @@ interface paths {
                             }[];
                             limit: number;
                             offset: number;
-                            hasMore?: boolean;
+                            hasMore: boolean;
                             total?: number;
                         };
                     };
@@ -1670,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[];
                     };
                 };
@@ -1700,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;
@@ -1766,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;
@@ -1985,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;
@@ -2108,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[];
                     };
                 };
@@ -2137,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;
@@ -2304,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;
@@ -2710,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[];
                     };
                 };
@@ -3523,6 +3530,7 @@ interface paths {
                     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;
@@ -3563,6 +3571,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;
@@ -3571,8 +3580,7 @@ interface paths {
                             }[];
                             limit: number;
                             offset: number;
-                            hasMore?: boolean;
-                            total?: number;
+                            hasMore: boolean;
                         };
                     };
                 };
@@ -3629,7 +3637,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[];
                     };
                 };
@@ -3663,6 +3674,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;
@@ -3739,6 +3751,63 @@ interface paths {
         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;
@@ -3786,6 +3855,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;
@@ -3918,6 +3988,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[];
                     };
                 };
@@ -3951,6 +4022,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;
@@ -5913,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: {
@@ -7471,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";
                             }[];
@@ -8937,8 +9042,7 @@ interface paths {
                             }[];
                             limit: number;
                             offset: number;
-                            hasMore?: boolean;
-                            total?: number;
+                            hasMore: boolean;
                         };
                     };
                 };

package/dist/openapi.d.ts

@@ -914,11 +914,6 @@ interface paths {
                 content: {
                     "application/json": {
                         code?: string;
-                        /**
-                         * @default product
-                         * @enum {string}
-                         */
-                        entityKind?: "product" | "content";
                         label?: {
                             [key: string]: string;
                         };
@@ -1575,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;
@@ -1621,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;
@@ -1631,7 +1628,7 @@ interface paths {
                             }[];
                             limit: number;
                             offset: number;
-                            hasMore?: boolean;
+                            hasMore: boolean;
                             total?: number;
                         };
                     };
@@ -1670,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[];
                     };
                 };
@@ -1700,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;
@@ -1766,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;
@@ -1985,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;
@@ -2108,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[];
                     };
                 };
@@ -2137,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;
@@ -2304,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;
@@ -2710,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[];
                     };
                 };
@@ -3523,6 +3530,7 @@ interface paths {
                     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;
@@ -3563,6 +3571,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;
@@ -3571,8 +3580,7 @@ interface paths {
                             }[];
                             limit: number;
                             offset: number;
-                            hasMore?: boolean;
-                            total?: number;
+                            hasMore: boolean;
                         };
                     };
                 };
@@ -3629,7 +3637,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[];
                     };
                 };
@@ -3663,6 +3674,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;
@@ -3739,6 +3751,63 @@ interface paths {
         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;
@@ -3786,6 +3855,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;
@@ -3918,6 +3988,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[];
                     };
                 };
@@ -3951,6 +4022,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;
@@ -5913,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: {
@@ -7471,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";
                             }[];
@@ -8937,8 +9042,7 @@ interface paths {
                             }[];
                             limit: number;
                             offset: number;
-                            hasMore?: boolean;
-                            total?: number;
+                            hasMore: boolean;
                         };
                     };
                 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@minipim/sdk",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Typed TypeScript client for the MiniPim API.",
   "license": "Apache-2.0",
   "homepage": "https://github.com/Epic-Design-Labs/minipim",