@proveanything/smartlinks 2.1.10 → 2.1.11

package/dist/api/claimSet.d.ts

@@ -1,4 +1,4 @@
-import { UpdateClaimDataRequest, AssignClaimsRequest, CreateClaimSetTagRequest, CreateClaimSetTagResponse, CreateClaimSetRequest, ImportClaimSetTagsRequest, ImportClaimSetTagsResponse } from "../types/index.js";
+import { ClaimSetScope, ClaimSetRange, CreateClaimSetRangeRequest, UpdateClaimSetRangeRequest, ClaimSetRangeTagsPage, ClaimSetRangeTag, ClaimSetRangeNextTag, ImportClaimSetRangeUidsRequest, ImportClaimSetRangeUidsResponse, AssignClaimSetRangeRequest, AssignClaimSetRangeResponse, ClaimSetRangeFile, UpdateClaimDataRequest, AssignClaimsRequest, CreateClaimSetTagRequest, CreateClaimSetTagResponse, CreateClaimSetRequest, ImportClaimSetTagsRequest, ImportClaimSetTagsResponse } from "../types/index.js";
 export declare namespace claimSet {
     /**
      * Get all claim sets.
@@ -95,4 +95,40 @@ export declare namespace claimSet {
      * @param data – Claim data to update
      */
     function updateClaimData(collectionId: string, data: UpdateClaimDataRequest): Promise<any>;
+    namespace ranges {
+        /** The ranges in a set, lowest index first. */
+        function list(scope: ClaimSetScope, claimSetId: string): Promise<ClaimSetRange[]>;
+        /** Reserve the set's next indexes and mint a code (and, for NTAG 424, a key) for each. */
+        function create(scope: ClaimSetScope, claimSetId: string, params: CreateClaimSetRangeRequest): Promise<ClaimSetRange>;
+        /** One range, with its counts refreshed. */
+        function get(scope: ClaimSetScope, claimSetId: string, rangeId: string): Promise<ClaimSetRange>;
+        /** Name, notes, order details, or a stage move (sent to the printer, received). */
+        function update(scope: ClaimSetScope, claimSetId: string, rangeId: string, params: UpdateClaimSetRangeRequest): Promise<ClaimSetRange>;
+        /** Finish minting a range that was interrupted. */
+        function resume(scope: ClaimSetScope, claimSetId: string, rangeId: string): Promise<ClaimSetRange>;
+        /** The range's tags in index order, a page at a time (keys: owners/admins only). */
+        function tags(scope: ClaimSetScope, claimSetId: string, rangeId: string, options?: {
+            from?: number;
+            limit?: number;
+            keys?: boolean;
+        }): Promise<ClaimSetRangeTagsPage>;
+        /** The next tag to program on a phone (lowest index without a chip), with its URL and key. */
+        function next(scope: ClaimSetScope, claimSetId: string, rangeId: string): Promise<ClaimSetRangeNextTag>;
+        /** Record the chip a phone just programmed with this code. */
+        function recordTag(scope: ClaimSetScope, claimSetId: string, rangeId: string, code: string, params: {
+            uid: string;
+            data?: Record<string, unknown>;
+        }): Promise<{
+            tag: ClaimSetRangeTag;
+            range: ClaimSetRange;
+        }>;
+        /** The printer file (CSV text in `csv`). Carries the tags' keys: don't keep it around. */
+        function exportFile(scope: ClaimSetScope, claimSetId: string, rangeId: string): Promise<ClaimSetRangeFile>;
+        /** The manufacturer's instruction sheet: PDF (base64) or Markdown. */
+        function instructions(scope: ClaimSetScope, claimSetId: string, rangeId: string, format?: 'pdf' | 'md'): Promise<ClaimSetRangeFile>;
+        /** The manufacturer's file back: check it (commit false), then write the chip UIDs (commit true). */
+        function importUids(scope: ClaimSetScope, claimSetId: string, rangeId: string, params: ImportClaimSetRangeUidsRequest): Promise<ImportClaimSetRangeUidsResponse>;
+        /** Point the range (or from–to within it) at a collection / product / batch, or clear it. */
+        function assign(scope: ClaimSetScope, claimSetId: string, rangeId: string, params: AssignClaimSetRangeRequest): Promise<AssignClaimSetRangeResponse>;
+    }
 }

package/dist/api/claimSet.js

@@ -1,4 +1,4 @@
-import { request, post, put, del } from "../http.js";
+import { request, post, put, patch, del } from "../http.js";
 /**
  * Returns the base path for claim set endpoints.
  * When collectionId is provided, routes to the collection-scoped admin API.
@@ -9,6 +9,13 @@ function base(collectionId) {
         ? `/admin/collection/${encodeURIComponent(collectionId)}/claimSet`
         : `/admin/claimSet`;
 }
+/** The range API's base for a scope: a collection's own sets, or a partner's sets. */
+function rangesBase(scope, claimSetId) {
+    const root = 'partnerId' in scope
+        ? `/admin/partner/${encodeURIComponent(scope.partnerId)}/claimSet`
+        : base(scope.collectionId);
+    return `${root}/${encodeURIComponent(claimSetId)}/ranges`;
+}
 export var claimSet;
 (function (claimSet) {
     /**
@@ -152,4 +159,79 @@ export var claimSet;
         return post(`${base(collectionId)}/updateClaimData`, data);
     }
     claimSet.updateClaimData = updateClaimData;
+    // ─── Ranges: mint, print, receive, assign ──────────────────────────────────────────────────────
+    // A range is a named, contiguous block of tags in one claim set. Scope: { collectionId } for a
+    // collection's own sets, { partnerId } for a partner's sets (see partner.*). Owners and admins mint,
+    // export, import and program; assigners assign. Responses are never cached (they carry keys).
+    let ranges;
+    (function (ranges) {
+        /** The ranges in a set, lowest index first. */
+        async function list(scope, claimSetId) {
+            return request(rangesBase(scope, claimSetId));
+        }
+        ranges.list = list;
+        /** Reserve the set's next indexes and mint a code (and, for NTAG 424, a key) for each. */
+        async function create(scope, claimSetId, params) {
+            return post(rangesBase(scope, claimSetId), params);
+        }
+        ranges.create = create;
+        /** One range, with its counts refreshed. */
+        async function get(scope, claimSetId, rangeId) {
+            return request(`${rangesBase(scope, claimSetId)}/${encodeURIComponent(rangeId)}`);
+        }
+        ranges.get = get;
+        /** Name, notes, order details, or a stage move (sent to the printer, received). */
+        async function update(scope, claimSetId, rangeId, params) {
+            return patch(`${rangesBase(scope, claimSetId)}/${encodeURIComponent(rangeId)}`, params);
+        }
+        ranges.update = update;
+        /** Finish minting a range that was interrupted. */
+        async function resume(scope, claimSetId, rangeId) {
+            return post(`${rangesBase(scope, claimSetId)}/${encodeURIComponent(rangeId)}/resume`, {});
+        }
+        ranges.resume = resume;
+        /** The range's tags in index order, a page at a time (keys: owners/admins only). */
+        async function tags(scope, claimSetId, rangeId, options = {}) {
+            const q = new URLSearchParams();
+            if (options.from !== undefined)
+                q.set('from', String(options.from));
+            if (options.limit !== undefined)
+                q.set('limit', String(options.limit));
+            if (options.keys)
+                q.set('keys', '1');
+            const qs = q.toString();
+            return request(`${rangesBase(scope, claimSetId)}/${encodeURIComponent(rangeId)}/tags${qs ? `?${qs}` : ''}`);
+        }
+        ranges.tags = tags;
+        /** The next tag to program on a phone (lowest index without a chip), with its URL and key. */
+        async function next(scope, claimSetId, rangeId) {
+            return request(`${rangesBase(scope, claimSetId)}/${encodeURIComponent(rangeId)}/next`);
+        }
+        ranges.next = next;
+        /** Record the chip a phone just programmed with this code. */
+        async function recordTag(scope, claimSetId, rangeId, code, params) {
+            return put(`${rangesBase(scope, claimSetId)}/${encodeURIComponent(rangeId)}/tags/${encodeURIComponent(code)}`, params);
+        }
+        ranges.recordTag = recordTag;
+        /** The printer file (CSV text in `csv`). Carries the tags' keys: don't keep it around. */
+        async function exportFile(scope, claimSetId, rangeId) {
+            return request(`${rangesBase(scope, claimSetId)}/${encodeURIComponent(rangeId)}/export?as=json`);
+        }
+        ranges.exportFile = exportFile;
+        /** The manufacturer's instruction sheet: PDF (base64) or Markdown. */
+        async function instructions(scope, claimSetId, rangeId, format = 'pdf') {
+            return request(`${rangesBase(scope, claimSetId)}/${encodeURIComponent(rangeId)}/instructions?format=${format}&as=json`);
+        }
+        ranges.instructions = instructions;
+        /** The manufacturer's file back: check it (commit false), then write the chip UIDs (commit true). */
+        async function importUids(scope, claimSetId, rangeId, params) {
+            return post(`${rangesBase(scope, claimSetId)}/${encodeURIComponent(rangeId)}/import`, params);
+        }
+        ranges.importUids = importUids;
+        /** Point the range (or from–to within it) at a collection / product / batch, or clear it. */
+        async function assign(scope, claimSetId, rangeId, params) {
+            return post(`${rangesBase(scope, claimSetId)}/${encodeURIComponent(rangeId)}/assign`, params);
+        }
+        ranges.assign = assign;
+    })(ranges = claimSet.ranges || (claimSet.ranges = {}));
 })(claimSet || (claimSet = {}));

package/dist/api/index.d.ts

@@ -10,6 +10,7 @@ export { auth } from "./auth.js";
 export { form } from "./form.js";
 export { authKit } from "./authKit.js";
 export { claimSet } from "./claimSet.js";
+export { partner } from "./partner.js";
 export { crate } from "./crate.js";
 export { batch } from "./batch.js";
 export { variant } from "./variant.js";

package/dist/api/index.js

@@ -12,6 +12,7 @@ export { auth } from "./auth.js";
 export { form } from "./form.js";
 export { authKit } from "./authKit.js";
 export { claimSet } from "./claimSet.js";
+export { partner } from "./partner.js";
 export { crate } from "./crate.js";
 export { batch } from "./batch.js";
 export { variant } from "./variant.js";

package/dist/api/partner.d.ts

@@ -0,0 +1,19 @@
+import { Partner, PartnerClaimSet, CreatePartnerClaimSetRequest } from "../types/index.js";
+/**
+ * Partners: organisations above collections (FanConnect, Zenith Coins, …) that own NFC claim sets and
+ * assign their tags into collections their people administer. Partners and their members are set up by
+ * SmartLinks staff; these calls are what a partner's people use. Ranges inside a partner's sets:
+ * claimSet.ranges.* with scope { partnerId }.
+ */
+export declare namespace partner {
+    /** The partners you belong to, with your role in each. Empty for everyone else. */
+    function list(): Promise<Partner[]>;
+    /** One partner (owners also see its members). */
+    function get(partnerId: string): Promise<Partner>;
+    /** The partner's claim sets. */
+    function claimSets(partnerId: string): Promise<PartnerClaimSet[]>;
+    /** One of the partner's claim sets. */
+    function getClaimSet(partnerId: string, claimSetId: string): Promise<PartnerClaimSet>;
+    /** A new claim set for the partner, on one of its tap domains (owners and admins). */
+    function createClaimSet(partnerId: string, params: CreatePartnerClaimSetRequest): Promise<PartnerClaimSet>;
+}

package/dist/api/partner.js

@@ -0,0 +1,35 @@
+import { request, post } from "../http.js";
+/**
+ * Partners: organisations above collections (FanConnect, Zenith Coins, …) that own NFC claim sets and
+ * assign their tags into collections their people administer. Partners and their members are set up by
+ * SmartLinks staff; these calls are what a partner's people use. Ranges inside a partner's sets:
+ * claimSet.ranges.* with scope { partnerId }.
+ */
+export var partner;
+(function (partner) {
+    /** The partners you belong to, with your role in each. Empty for everyone else. */
+    async function list() {
+        return request(`/admin/partner`);
+    }
+    partner.list = list;
+    /** One partner (owners also see its members). */
+    async function get(partnerId) {
+        return request(`/admin/partner/${encodeURIComponent(partnerId)}`);
+    }
+    partner.get = get;
+    /** The partner's claim sets. */
+    async function claimSets(partnerId) {
+        return request(`/admin/partner/${encodeURIComponent(partnerId)}/claimSet`);
+    }
+    partner.claimSets = claimSets;
+    /** One of the partner's claim sets. */
+    async function getClaimSet(partnerId, claimSetId) {
+        return request(`/admin/partner/${encodeURIComponent(partnerId)}/claimSet/${encodeURIComponent(claimSetId)}`);
+    }
+    partner.getClaimSet = getClaimSet;
+    /** A new claim set for the partner, on one of its tap domains (owners and admins). */
+    async function createClaimSet(partnerId, params) {
+        return post(`/admin/partner/${encodeURIComponent(partnerId)}/claimSet`, params);
+    }
+    partner.createClaimSet = createClaimSet;
+})(partner || (partner = {}));

package/dist/docs/API_SUMMARY.md

@@ -1,6 +1,6 @@
 # Smartlinks API Summary
 
-Version: 2.1.10  |  Generated: 2026-11-03T16:21:02.896Z
+Version: 2.1.11  |  Generated: 2026-11-08T09:25:58.482Z
 
 This is a concise summary of all available API functions and types.
 
@@ -153,6 +153,7 @@ The Smartlinks SDK is organized into the following namespaces:
 - **lots** - Functions for lots operations
 - **navigation** - Functions for navigation operations
 - **order** - Functions for order operations
+- **partner** - Functions for partner operations
 - **products** - Functions for products operations
 - **realtime** - Functions for realtime operations
 - **research** - Functions for research operations
@@ -186,17 +187,17 @@ The release channel explicitly set for this app build (initializeApi({ appChanne
 **setAppChannel**(channel: string | undefined) → `void`
 Set (or clear) the release channel SL.functions calls target.
 
-**initializeApi**(options: {
-  baseURL: string
-  apiKey?: string
-  bearerToken?: string
-  proxyMode?: boolean
-  ngrokSkipBrowserWarning?: boolean
-  extraHeaders?: Record<string, string>
-  /**
-   * Declares the host platform. Set to `'native'` on native/Capacitor hosts to opt into
-   * AuthKit refresh tokens — the SDK then sends `X-Client-Platform: native` on every
-   * request, so login endpoints return `refreshToken`/`refreshTokenExpiresAt` and a
+**initializeApi**(options: {
+  baseURL: string
+  apiKey?: string
+  bearerToken?: string
+  proxyMode?: boolean
+  ngrokSkipBrowserWarning?: boolean
+  extraHeaders?: Record<string, string>
+  /**
+   * Declares the host platform. Set to `'native'` on native/Capacitor hosts to opt into
+   * AuthKit refresh tokens — the SDK then sends `X-Client-Platform: native` on every
+   * request, so login endpoints return `refreshToken`/`refreshTokenExpiresAt` and a
    * short-lived access token. Omit (or `'web'`) → `void`
 Call this once (e.g. at app startup) to configure baseURL/auth.
 
@@ -227,56 +228,56 @@ Returns true if initializeApi() has been called at least once. Useful for guards
 **hasAuthCredentials**() → `boolean`
 Returns true if the SDK currently has any auth credential set (bearer token or API key). Use this as a cheap pre-flight check before calling endpoints that require authentication, to avoid issuing a network request that you already know will return a 401. ```ts if (hasAuthCredentials()) { const account = await auth.getAccount() } ```
 
-**configureSdkCache**(options: {
-  enabled?: boolean
-  ttlMs?: number
-  maxEntries?: number
-  persistence?: 'none' | 'indexeddb'
-  persistenceTtlMs?: number
-  serveStaleOnOffline?: boolean
-  clearOnPageLoad?: boolean
+**configureSdkCache**(options: {
+  enabled?: boolean
+  ttlMs?: number
+  maxEntries?: number
+  persistence?: 'none' | 'indexeddb'
+  persistenceTtlMs?: number
+  serveStaleOnOffline?: boolean
+  clearOnPageLoad?: boolean
 }) → `void`
 Configure the SDK's built-in in-memory GET cache. The cache is transparent — it sits inside the HTTP layer and requires no changes to your existing API calls. All GET requests benefit automatically. Per-resource rules (collections/products → 1 h, proofs → 30 s, etc.) override this value. in-memory only (`'none'`, default). Ignored in Node.js. fallback, from the original fetch time (default: 7 days). `SmartlinksOfflineError` with stale data instead of propagating the network error. caches on page load/refresh. IndexedDB persists for offline. ```ts // Enable IndexedDB persistence for offline support configureSdkCache({ persistence: 'indexeddb' }) // Disable cache entirely in test environments configureSdkCache({ enabled: false }) // Keep caches across page refreshes (not recommended for production) configureSdkCache({ clearOnPageLoad: false }) ```
 
 **invalidateCache**(urlPattern?: string, options?: InvalidateCacheOptions) → `void`
 Manually invalidate entries in the SDK's GET cache. Note: the GET cache is **in-memory, per page load** (with an optional L2 IndexedDB layer when persistence is enabled) — it does not persist across reloads unless you opt into persistence, so it rarely needs disabling "for correctness". *contains* this string is removed). With `{ exact: true }`, matches the path precisely. Omit to wipe the entire cache. ```ts invalidateCache()                                  // clear everything invalidateCache('/collection/abc123')              // that collection AND everything under it invalidateCache('/collection/abc123', { exact: true }) // ONLY that collection entry invalidateCache('/products/')                      // all canonical plural product responses ```
 
-**proxyUploadFormData**(path: string,
-  formData: FormData,
+**proxyUploadFormData**(path: string,
+  formData: FormData,
   onProgress?: (percent: number) → `void`
 Upload a FormData payload via proxy with progress events using chunked postMessage. Parent is expected to implement the counterpart protocol.
 
 **request**(path: string) → `Promise<T>`
 Internal helper that performs a GET request to `${baseURL}${path}`, injecting headers for apiKey or bearerToken if present. Cache pipeline (when caching is not skipped): L1 hit  → return from memory (no I/O) L2 hit  → return from IndexedDB, promote to L1 (no network) Miss    → fetch from network, store in L1 + L2 Offline → serve stale L2 entry via SmartlinksOfflineError (if persistence enabled) Concurrent identical GETs share one in-flight promise (deduplication). Node-safe: IndexedDB calls are no-ops when IDB is unavailable.
 
-**post**(path: string,
-  body: any,
+**post**(path: string,
+  body: any,
   extraHeaders?: Record<string, string>) → `Promise<T>`
 Internal helper that performs a POST request to `${baseURL}${path}`, injecting headers for apiKey or bearerToken if present. If body is FormData, Content-Type is not set. Returns the parsed JSON as T, or throws an Error.
 
-**put**(path: string,
-  body: any,
+**put**(path: string,
+  body: any,
   extraHeaders?: Record<string, string>) → `Promise<T>`
 Internal helper that performs a PUT request to `${baseURL}${path}`, injecting headers for apiKey or bearerToken if present. If body is FormData, Content-Type is not set. Returns the parsed JSON as T, or throws an Error.
 
-**patch**(path: string,
-  body: any,
+**patch**(path: string,
+  body: any,
   extraHeaders?: Record<string, string>) → `Promise<T>`
 Internal helper that performs a PATCH request to `${baseURL}${path}`, injecting headers for apiKey or bearerToken if present. If body is FormData, Content-Type is not set. Returns the parsed JSON as T, or throws an Error.
 
-**requestWithOptions**(path: string,
+**requestWithOptions**(path: string,
   options: RequestInit) → `Promise<T>`
 Internal helper that performs a request to `${baseURL}${path}` with custom options, injecting headers for apiKey or bearerToken if present. Returns the parsed JSON as T, or throws an Error.
 
-**requestStream**(path: string,
-  options?: {
-    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE'
-    body?: any
-    headers?: Record<string, string>
+**requestStream**(path: string,
+  options?: {
+    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE'
+    body?: any
+    headers?: Record<string, string>
   }) → `Promise<AsyncIterable<T>>`
 Internal helper that performs a streaming request using the shared auth and proxy transport. The response is expected to be `text/event-stream` with JSON payloads in `data:` frames.
 
-**del**(path: string,
+**del**(path: string,
   extraHeaders?: Record<string, string>) → `Promise<T>`
 Internal helper that performs a DELETE request to `${baseURL}${path}`, injecting headers for apiKey or bearerToken if present. Returns the parsed JSON as T, or throws an Error.
 
@@ -5731,6 +5732,188 @@ interface CreateClaimSetTagResponse {
 }
 ```
 
+**ClaimSetRange** (interface)
+```typescript
+interface ClaimSetRange {
+  id: string
+  claimSetId: string
+  namespace: string
+  name: string
+  notes: string | null
+  startIndex: number
+  endIndex: number
+  quantity: number
+  tagType: ClaimSetTagType
+  fulfilment: 'printer' | 'sidekick'
+  stage: 'minting' | 'minted' | 'sent' | 'received'
+  status: ClaimSetRangeStatus
+  intendedCollectionId: string | null
+  intendedProductId: string | null
+  intendedBatchId: string | null
+  manufacturer: string | null
+  orderRef: string | null
+  counts: { programmed: number; assigned: number; claimed: number }
+  sentAt: string | null
+  receivedAt: string | null
+  createdBy: string | null
+  createdAt: string
+  updatedAt: string
+}
+```
+
+**CreateClaimSetRangeRequest** (interface)
+```typescript
+interface CreateClaimSetRangeRequest {
+  name: string
+  quantity: number
+  intendedCollectionId?: string
+  intendedProductId?: string
+  intendedBatchId?: string
+  fulfilment?: 'printer' | 'sidekick'
+  notes?: string
+  manufacturer?: string
+  orderRef?: string
+}
+```
+
+**UpdateClaimSetRangeRequest** (interface)
+```typescript
+interface UpdateClaimSetRangeRequest {
+  name?: string
+  notes?: string | null
+  manufacturer?: string | null
+  orderRef?: string | null
+  fulfilment?: 'printer' | 'sidekick'
+  stage?: 'minted' | 'sent' | 'received'
+}
+```
+
+**ClaimSetRangeTag** (interface)
+```typescript
+interface ClaimSetRangeTag {
+  code: string
+  printed: string
+  index: number
+  uid: string | null
+  key?: string
+  collectionId: string | null
+  productId: string | null
+  batchId: string | null
+  proofId: string | null
+  programmedAt: string | null
+  scans: number
+}
+```
+
+**ClaimSetRangeTagsPage** (interface)
+```typescript
+interface ClaimSetRangeTagsPage {
+  tags: ClaimSetRangeTag[]
+  next: number | null
+}
+```
+
+**ImportClaimSetRangeUidsRequest** (interface)
+```typescript
+interface ImportClaimSetRangeUidsRequest {
+  csv?: string
+  rows?: Array<Record<string, string | number>>
+  commit?: boolean
+}
+```
+
+**ImportClaimSetRangeUidsResponse** (interface)
+```typescript
+interface ImportClaimSetRangeUidsResponse {
+  summary: { rows: number; ok: number; unchanged: number; problems: number; notInFile: number; committed: boolean }
+  rows: Array<{ line: number; code: string; index: number | null; uid: string; result: ClaimSetImportResult; message?: string }>
+  range: ClaimSetRange
+}
+```
+
+**AssignClaimSetRangeRequest** (interface)
+```typescript
+interface AssignClaimSetRangeRequest {
+  collectionId?: string
+  productId?: string
+  batchId?: string
+  start?: number
+  end?: number
+  clear?: boolean
+  data?: Record<string, unknown>
+}
+```
+
+**AssignClaimSetRangeResponse** (interface)
+```typescript
+interface AssignClaimSetRangeResponse {
+  changed: number
+  skipped: Array<{ code: string; index: number; reason: 'other_range' | 'has_proof' | 'assigned_elsewhere'; collectionId?: string }>
+  range: ClaimSetRange
+}
+```
+
+**ClaimSetRangeFile** (interface)
+```typescript
+interface ClaimSetRangeFile {
+  filename: string
+  contentType: string
+  csv?: string
+  base64?: string
+  markdown?: string
+}
+```
+
+**Partner** (interface)
+```typescript
+interface Partner {
+  id: string
+  name: string
+  status: 'active' | 'suspended'
+  tapDomains: string[]
+  features: Record<string, boolean>
+  role?: 'owner' | 'admin' | 'assigner'
+  members?: Array<{ userId: string; role: 'owner' | 'admin' | 'assigner'; grantedBy: string | null; grantedAt: string }>
+  createdAt: string
+  updatedAt: string
+}
+```
+
+**PartnerClaimSet** (interface)
+```typescript
+interface PartnerClaimSet {
+  id: string
+  namespace: string
+  name: string | null
+  tagType: ClaimSetTagType
+  tapDomain: string
+  owner: { type: 'platform' | 'partner' | 'collection' | 'user'; id: string | null }
+  codes: number
+  deleted: boolean
+  createdAt: string | null
+}
+```
+
+**CreatePartnerClaimSetRequest** (interface)
+```typescript
+interface CreatePartnerClaimSetRequest {
+  name: string
+  tagType: ClaimSetTagType
+  tapDomain?: string
+}
+```
+
+**ClaimSetScope** (type)
+```typescript
+type ClaimSetScope = { collectionId: string }
+```
+
+**ClaimSetTagType** = `'ntag424' | 'ntag21x' | 'qr'`
+
+**ClaimSetRangeStatus** = `'minting' | 'minted' | 'sent' | 'received' | 'assigned'`
+
+**ClaimSetImportResult** = ``
+
 ### collection
 
 **Collection** (interface)
@@ -12119,6 +12302,46 @@ Assign claims to codes or ranges within a collection.
 **updateClaimData**(collectionId: string, data: UpdateClaimDataRequest) → `Promise<any>`
 Update claim data for a claim set (collection-scoped).
 
+### claimSet.ranges
+
+**list**(scope: ClaimSetScope, claimSetId: string) → `Promise<ClaimSetRange[]>`
+The ranges in a set, lowest index first.
+
+**create**(scope: ClaimSetScope, claimSetId: string, params: CreateClaimSetRangeRequest) → `Promise<ClaimSetRange>`
+Reserve the set's next indexes and mint a code (and, for NTAG 424, a key) for each.
+
+**get**(scope: ClaimSetScope, claimSetId: string, rangeId: string) → `Promise<ClaimSetRange>`
+One range, with its counts refreshed.
+
+**update**(scope: ClaimSetScope, claimSetId: string, rangeId: string, params: UpdateClaimSetRangeRequest) → `Promise<ClaimSetRange>`
+Name, notes, order details, or a stage move (sent to the printer, received).
+
+**resume**(scope: ClaimSetScope, claimSetId: string, rangeId: string) → `Promise<ClaimSetRange>`
+Finish minting a range that was interrupted.
+
+**tags**(scope: ClaimSetScope, claimSetId: string, rangeId: string,
+      options: { from?: number; limit?: number; keys?: boolean } = {}) → `Promise<ClaimSetRangeTagsPage>`
+The range's tags in index order, a page at a time (keys: owners/admins only).
+
+**next**(scope: ClaimSetScope, claimSetId: string, rangeId: string) → `Promise<ClaimSetRangeNextTag>`
+The next tag to program on a phone (lowest index without a chip), with its URL and key.
+
+**recordTag**(scope: ClaimSetScope, claimSetId: string, rangeId: string, code: string,
+      params: { uid: string; data?: Record<string, unknown> }) → `Promise<`
+Record the chip a phone just programmed with this code.
+
+**exportFile**(scope: ClaimSetScope, claimSetId: string, rangeId: string) → `Promise<ClaimSetRangeFile>`
+The printer file (CSV text in `csv`). Carries the tags' keys: don't keep it around.
+
+**instructions**(scope: ClaimSetScope, claimSetId: string, rangeId: string, format: 'pdf' | 'md' = 'pdf') → `Promise<ClaimSetRangeFile>`
+The manufacturer's instruction sheet: PDF (base64) or Markdown.
+
+**importUids**(scope: ClaimSetScope, claimSetId: string, rangeId: string, params: ImportClaimSetRangeUidsRequest) → `Promise<ImportClaimSetRangeUidsResponse>`
+The manufacturer's file back: check it (commit false), then write the chip UIDs (commit true).
+
+**assign**(scope: ClaimSetScope, claimSetId: string, rangeId: string, params: AssignClaimSetRangeRequest) → `Promise<AssignClaimSetRangeResponse>`
+Point the range (or from–to within it) at a collection / product / batch, or clear it.
+
 ### collection
 
 **get**(collectionId: string, admin?: boolean) → `Promise<CollectionResponse>`
@@ -13030,6 +13253,23 @@ Get individual order items for a specific product. Returns all matching items wi
     params?: GetOrderIdsParams) → `Promise<GetOrderIdsResponse>`
 Get unique order IDs containing items for a specific product. Lightweight query that only returns order IDs, not full order objects. ```typescript // Get order IDs for a product const productOrders = await order.getOrderIdsByAttribute( 'coll_123', 'productId', 'prod_789', { limit: 500 } ) ```
 
+### partner
+
+**list**() → `Promise<Partner[]>`
+The partners you belong to, with your role in each. Empty for everyone else.
+
+**get**(partnerId: string) → `Promise<Partner>`
+One partner (owners also see its members).
+
+**claimSets**(partnerId: string) → `Promise<PartnerClaimSet[]>`
+The partner's claim sets.
+
+**getClaimSet**(partnerId: string, claimSetId: string) → `Promise<PartnerClaimSet>`
+One of the partner's claim sets.
+
+**createClaimSet**(partnerId: string, params: CreatePartnerClaimSetRequest) → `Promise<PartnerClaimSet>`
+A new claim set for the partner, on one of its tap domains (owners and admins).
+
 ### podcast
 
 **generate**(collectionId: string,