@stackshift-cloud/sdk 1.1.0 → 1.3.0

package/README.md

@@ -2,6 +2,26 @@
 
 Official JavaScript and TypeScript SDK for StackShift.
 
+## Governed media and galleries
+
+Use a separate server-side client for each Assets space; the namespace is fixed on that client. Project membership does not grant Assets access.
+
+```ts
+const studio = new StackShift({
+  apiKey: process.env.STACKSHIFT_API_KEY,
+  assetSpaceId: 'your-asset-space-uuid',
+})
+const page = await studio.assets.dam.publications({ status: 'published' })
+if (page.next_cursor) {
+  const next = await studio.assets.dam.publications({ status: 'published', cursor: page.next_cursor })
+}
+const gallery = await studio.assets.dam.resolveGallery('published-gallery-uuid')
+```
+
+`assets.dam` also exposes collaborators, typed metadata schemas, bucket governance, publication transitions, model processing, gallery drafts and picker capabilities. Updates use explicit revisions. Submission needs `assets:write`, review needs `assets:admin`, and publication/withdrawal needs `assets:publish`, in addition to the corresponding Assets grant.
+
+Keep account credentials on your server. Give `@stackshift-cloud/assets-picker` a short-lived, origin-restricted capability; give `@stackshift-cloud/assets-gallery` a server resolver for approved media. Store publication/gallery IDs and versions, never delivery URLs. Model processing is an explicitly enabled pilot and requires the qualified isolated worker described in `packages/assets-model-processor/README.md`.
+
 ## Install
 
 ```bash
@@ -14,6 +34,27 @@ Set your API key:
 STACKSHIFT_API_KEY=sk_live_xxx
 ```
 
+## AI credits
+
+AI credits are account-scoped. Inspect the balance and usage, create a top-up checkout, or choose managed billing versus your own provider key:
+
+```ts
+import { StackShift } from '@stackshift-cloud/sdk'
+
+const stackshift = new StackShift()
+const balance = await stackshift.aiCredits.balance()
+const usage = await stackshift.aiCredits.usage({ product: 'assets', limit: 25 })
+const quote = await stackshift.aiCredits.quote(1_000, 'USD')
+const checkout = await stackshift.aiCredits.checkout({
+  quote_id: quote.id,
+  idempotency_key: crypto.randomUUID(),
+  provider: 'paystack',
+})
+await stackshift.aiCredits.setFunding('assets', 'managed')
+```
+
+Keep account API keys and checkout creation on your server. An Assets space ID does not change which billing account these methods use.
+
 ## Send email
 
 ```ts
@@ -276,7 +317,7 @@ const capability = await stackshift.assets.uploadCapabilities.create({
 })
 ```
 
-Create capabilities only in trusted backend code. Send `capability.token` to `@stackshift/assets-widget`; never put the Stackshift API key in a browser bundle.
+Create capabilities only in trusted backend code. Send `capability.token` to `@stackshift-cloud/assets-widget`; never put the Stackshift API key in a browser bundle.
 
 For larger uploads, create a signed upload URL on your NestJS server and let the browser upload directly.
 
@@ -307,3 +348,40 @@ await fetch(upload.url, {
 This is the recommended pattern for React, Next.js, TanStack Start, and any browser app. The browser never receives your StackShift API key.
 
 StackShift chooses storage nodes, writes to StackShift-owned disks, replicates internally, and returns CDN-ready asset URLs. SDK users never choose storage nodes and never receive disk paths.
+
+### Campaign drafts and engagement
+
+Create campaigns with `content: { subject, html, text, editorMode: 'code' }`, or keep using a template/version. `mail.campaigns.update(id, { ...draft, revision })` saves a full draft; `preview`, `test`, `send(id, revision)`, and `schedule(id, sendAt, revision)` support review and dispatch. A stale revision returns 409.
+
+Mail send inputs accept `tracking: { opens: false, clicks: true }`. Each omitted setting inherits the workspace default. Use `mail.tracking.settings()` / `updateSettings()`, `message(id)` / `campaign(id)` for reports, and `domains()` / `createDomain()` / `verifyDomain()` / `updateDomain()` for branded hosts. Features must be enabled on the deployment. Opens are approximate; suspected automation is reported separately. Detailed activity expires after 90 days. Tests and OTPs never track.
+
+### Isolated testing, brands, migration, and spending
+
+Use a `sspat_test_` credential with `simulation: { scenario: 'delayed' }` for a 60-second simulated delay. Other outcomes are delivered, bounced, and complained. Test resources are isolated; no real email is delivered.
+
+```ts
+const brand = await client.mail.brands.create({ name: 'Product', editableFields: ['company'] })
+const audience = await client.mail.audiences.create({ brandId: brand.id, name: 'Product news' })
+```
+
+Every audience requires an explicit brand. Contact names/attributes are shared within that brand while consent stays per audience. `mail.automations`, `mail.forms`, and `mail.segments` expose audience-owned resources.
+
+`mail.migration` supports public DNS audits/plans and authenticated checklists. `mail.billing.summary()` and `mail.campaigns.estimate(id)` expose allowance, credit, and blocking reasons. Pass approved maximum kobo as the third argument to `send(id, revision, approvedMaxKobo)` or the fourth to `schedule(id, sendAt, revision, approvedMaxKobo)`. Zero is a valid hard maximum. Billing is inactive until a rate card is explicitly published and activated; funding and prepaid opt-in are separate owner-only dashboard actions.
+
+## Native video, governed DAM and product rendering
+
+Use the space-scoped DAM and video clients for collaborators, metadata schemas, bucket governance, reviewed publications, picker capabilities, model preparation, product rendering, galleries, version-pinned encoding, captions and playback sessions.
+
+```ts
+const dam = sdk.assets.dam
+const video = sdk.assets.video
+const schema = await dam.createMetadataSchema({ name: 'Products', fields: [{
+  key: 'product_name', label: 'Product name', type: 'text', required: true,
+}] })
+const published = await dam.publishMetadataSchema(schema.id, schema.revision)
+const workspace = await video.workspace(assetId)
+```
+
+Mutations carry the supplied revision in `If-Match`. Model preparation and rendering carry an idempotency key; render submission also carries the accepted maximum units. Playback renewal and events authenticate with the session credential, not the account key. Keep these clients on your backend and return grants with `Cache-Control: private, no-store`.
+
+See the [Assets SDK guide](https://docs.stackshift.cloud/assets/sdk-media-workflows) and its linked feature guides for complete language examples, inputs, permissions, review transitions and browser callbacks.

package/dist/ai-credits.d.ts

@@ -0,0 +1,78 @@
+import type { StackShift } from './client.js';
+export interface AICreditGrant {
+    id: string;
+    kind: string;
+    source: string;
+    policy_revision: number;
+    amount_microcredits: number;
+    remaining_microcredits: number;
+    available_at: string;
+    expires_at: string | null;
+}
+export interface AICreditBalance {
+    available_microcredits: number;
+    monthly_microcredits: number;
+    purchased_microcredits: number;
+    reserved_microcredits: number;
+    shortfall_microcredits: number;
+    next_reset: string;
+    grants: AICreditGrant[];
+}
+export interface AICreditUsage {
+    id: string;
+    operation_key: string;
+    product: string;
+    feature: string;
+    user_id: string;
+    project_id?: string;
+    space_id?: string;
+    parent_task_id?: string;
+    funding_mode: string;
+    state: string;
+    created_at: string;
+    reserved_microcredits: number;
+    used_microcredits: number;
+    returned_microcredits: number;
+}
+export interface AICreditUsagePage {
+    items: AICreditUsage[];
+    totals_microcredits: Record<string, number>;
+}
+export interface AICreditQuote {
+    id: string;
+    catalog_revision: number;
+    credit_microcredits: number;
+    amount_minor: number;
+    currency: string;
+    expires_at: string;
+}
+export interface AICreditCheckout {
+    reference: string;
+    status: string;
+    authorization_url?: string;
+}
+export type AIFundingPreferences = Record<'assets' | 'agents' | 'workflows', 'managed' | 'byok'>;
+export declare class AICreditsClient {
+    private readonly client;
+    constructor(client: StackShift);
+    balance(): Promise<AICreditBalance>;
+    usage(filters?: {
+        product?: string;
+        user?: string;
+        project?: string;
+        space?: string;
+        from?: string;
+        until?: string;
+        before_time?: string;
+        before_id?: string;
+        limit?: number;
+    }): Promise<AICreditUsagePage>;
+    quote(credits: number, currency: 'USD' | 'NGN'): Promise<AICreditQuote>;
+    checkout(input: {
+        quote_id: string;
+        idempotency_key: string;
+        provider: string;
+    }): Promise<AICreditCheckout>;
+    funding(): Promise<AIFundingPreferences>;
+    setFunding(product: 'assets' | 'agents' | 'workflows', mode: 'managed' | 'byok'): Promise<AIFundingPreferences>;
+}

package/dist/ai-credits.js

@@ -0,0 +1,15 @@
+export class AICreditsClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    balance() { return this.client.request('/billing/ai-credits', { method: 'GET' }); }
+    usage(filters = {}) {
+        const query = new URLSearchParams(Object.entries(filters).filter(([, v]) => v !== undefined).map(([k, v]) => [k, String(v)]));
+        return this.client.request(`/billing/ai-credits/usage?${query}`, { method: 'GET' });
+    }
+    quote(credits, currency) { return this.client.request('/billing/ai-credits/top-ups/quote', { method: 'POST', body: { credits, currency } }); }
+    checkout(input) { return this.client.request('/billing/ai-credits/top-ups/checkout', { method: 'POST', body: input }); }
+    funding() { return this.client.request('/billing/ai-credits/funding', { method: 'GET' }); }
+    setFunding(product, mode) { return this.client.request('/billing/ai-credits/funding', { method: 'PUT', body: { product, mode } }); }
+}

package/dist/assets-dam-types.d.ts

@@ -0,0 +1,259 @@
+export type AssetAction = 'read' | 'upload' | 'edit_metadata' | 'process' | 'review' | 'publish' | 'download_original' | 'curate' | 'manage_policy' | 'manage_access';
+export interface AssetSpaceAccess {
+    id: string;
+    owner_id: string;
+    name: string;
+    actions: AssetAction[];
+    collection_ids: string[];
+}
+export interface AssetCollaborator {
+    id: string;
+    asset_space_id: string;
+    email: string;
+    user_id?: string;
+    collection_id?: string;
+    actions: AssetAction[];
+    status: string;
+    revision: number;
+    expires_at: string;
+}
+export interface AssetMetadataField {
+    key: string;
+    label: string;
+    type: 'text' | 'integer' | 'decimal' | 'boolean' | 'date' | 'single_choice' | 'multiple_choice';
+    required?: boolean;
+    searchable?: boolean;
+    options?: string[];
+    minimum?: number;
+    maximum?: number;
+    max_length?: number;
+}
+export interface AssetMetadataSchema {
+    id: string;
+    name: string;
+    revision: number;
+    published_revision?: number;
+    fields: AssetMetadataField[];
+}
+export interface AssetBucketGovernance {
+    bucket_id: string;
+    revision: number;
+    enabled: boolean;
+    migrating: boolean;
+    schema_id?: string;
+    schema_revision?: number;
+    require_other_reviewer: boolean;
+    allow_ar: boolean;
+    channels: string[];
+}
+export interface AssetMediaReference {
+    render_set_id?: string;
+    render_role?: string;
+    spin_frame?: number;
+    language?: string;
+    label?: string;
+    caption_kind?: 'captions' | 'subtitles';
+    is_default?: boolean;
+    asset_id: string;
+    version_id: string;
+    rendition_id: string;
+    kind: 'image' | 'video' | 'model' | 'usdz' | 'caption';
+    role: 'media' | 'poster' | 'fallback' | 'caption' | 'usdz' | 'spin_frame';
+    output_checksum_sha256?: string;
+    policy_revision?: number;
+}
+export interface AssetPublicationRights {
+    owner: string;
+    attribution: string;
+    starts_at?: string;
+    expires_at?: string;
+}
+export type AssetPublicationStatus = 'draft' | 'in_review' | 'approved' | 'published' | 'withdrawn';
+export interface AssetPublicationInput {
+    asset_id: string;
+    asset_revision: number;
+    channel: string;
+    renditions: AssetMediaReference[];
+    rights: AssetPublicationRights;
+}
+export interface AssetPublication {
+    id: string;
+    asset_id: string;
+    version_id: string;
+    channel: string;
+    status: AssetPublicationStatus;
+    revision: number;
+    metadata_revision: number;
+    metadata: Record<string, unknown>;
+    renditions: AssetMediaReference[];
+    rights: AssetPublicationRights;
+    reviewed_by?: string;
+    review_note?: string;
+}
+export interface AssetPublicationDelivery {
+    publication_id: string;
+    expires_at: string;
+    attribution: string;
+    ar_allowed: boolean;
+    renditions: Array<{
+        reference: AssetMediaReference;
+        url: string;
+        mp4_url?: string;
+        poster_url?: string;
+    }>;
+}
+export interface AssetPickerCapabilityInput {
+    buckets?: string[];
+    collections?: string[];
+    origins: string[];
+    channel: string;
+    result_limit?: number;
+    expires_in_seconds?: number;
+    actions?: ('search' | 'select')[];
+}
+export interface AssetPickerCapability {
+    id: string;
+    expires_at: string;
+    origins: string[];
+    channel: string;
+    result_limit: number;
+}
+export interface AssetModelPackage {
+    id: string;
+    asset_id: string;
+    version_id: string;
+    kind: 'glb' | 'usdz';
+    status: 'queued' | 'processing' | 'ready' | 'failed';
+    rendition_id?: string;
+    failure_reason?: string;
+    report: Record<string, unknown>;
+    updated_at: string;
+}
+export interface AssetModelTextureOverride {
+    texture_index: number;
+    asset_id: string;
+    version_id: string;
+    checksum_sha256: string;
+}
+export interface AssetModelVariant {
+    id: string;
+    asset_id: string;
+    source_version_id: string;
+    source_checksum_sha256: string;
+    name: string;
+    swatch: {
+        label: string;
+        color: string;
+    };
+    texture_overrides: AssetModelTextureOverride[];
+    revision: number;
+}
+export interface AssetModelVariantInput {
+    name: string;
+    source_version_id: string;
+    source_checksum_sha256: string;
+    swatch: {
+        label: string;
+        color: string;
+    };
+    texture_overrides: AssetModelTextureOverride[];
+    expected_revision?: number;
+}
+export interface AssetGalleryEntryInput {
+    publication_id: string;
+    fallback_publication_id?: string;
+    role: 'hero' | 'detail' | 'media';
+    locale: string;
+    alt: string;
+}
+export interface AssetGalleryEntry extends AssetGalleryEntryInput {
+    asset_id: string;
+    version_id: string;
+    publication_revision: number;
+    fallback_revision?: number;
+}
+export interface AssetGallery {
+    id: string;
+    name: string;
+    revision: number;
+    published_revision?: number;
+    entries: AssetGalleryEntry[];
+}
+export interface AssetGalleryDelivery {
+    gallery_id: string;
+    name: string;
+    revision: number;
+    entries: Array<{
+        reference: AssetGalleryEntry;
+        delivery?: AssetPublicationDelivery;
+        fallback_delivery?: AssetPublicationDelivery;
+        unavailable?: boolean;
+    }>;
+}
+export interface AssetRenderRecipe {
+    environment: 'neutral' | 'pillars';
+    orbit: number;
+    elevation: number;
+    zoom: number;
+    exposure: number;
+    shadow: number;
+    background: string;
+    size: 512 | 1024;
+}
+export type AssetRenderOutput = 'proof' | 'poster' | 'spin' | 'turntable' | 'model' | 'usdz';
+export interface AssetRenderInput {
+    version_id: string;
+    source_checksum: string;
+    recipe: AssetRenderRecipe;
+    outputs: AssetRenderOutput[];
+    variant_id?: string;
+    variant_revision?: number;
+}
+export interface AssetRenderEstimate {
+    units: number;
+    remaining: number;
+    reused: boolean;
+    set_id?: string;
+}
+export interface AssetRenderSubmission {
+    set_id: string;
+    status: string;
+    job_id?: string;
+    units?: number;
+    reused?: boolean;
+}
+export interface AssetRenderSet {
+    id: string;
+    asset_id: string;
+    version_id: string;
+    source_checksum: string;
+    recipe: AssetRenderRecipe;
+    requested: AssetRenderOutput[];
+    variant_id?: string;
+    variant_revision?: number;
+    status: 'queued' | 'processing' | 'ready' | 'failed';
+    can_retry: boolean;
+    units: number;
+    outputs: Array<{
+        role: AssetRenderOutput;
+        frame: number;
+        reference: AssetMediaReference;
+    }>;
+    created_at: string;
+    updated_at: string;
+    failure_reason?: string;
+}
+export interface AssetRenderingInfo {
+    enabled: boolean;
+    reason: string;
+    remaining: number;
+    qualified_outputs: AssetRenderOutput[];
+    source?: {
+        assetId: string;
+        versionId: string;
+        checksum: string;
+    };
+    delivery?: AssetPublicationDelivery;
+    sets: AssetRenderSet[];
+    deliveries: Record<string, AssetPublicationDelivery>;
+}

package/dist/assets-dam-types.js

@@ -0,0 +1 @@
+export {};

package/dist/assets-dam.d.ts

@@ -0,0 +1,106 @@
+import type { StackShift } from './client.js';
+import type { AssetJobSubmission } from './types.js';
+import type { AssetRenderInput, AssetRenderEstimate, AssetRenderSubmission, AssetRenderingInfo } from './assets-dam-types.js';
+import type { AssetAction, AssetSpaceAccess, AssetCollaborator, AssetMetadataSchema, AssetMetadataField, AssetBucketGovernance, AssetPublication, AssetPublicationInput, AssetPublicationStatus, AssetPublicationDelivery, AssetMediaReference, AssetPickerCapability, AssetPickerCapabilityInput, AssetModelPackage, AssetModelVariant, AssetModelVariantInput, AssetGallery, AssetGalleryEntryInput, AssetGalleryDelivery } from './assets-dam-types.js';
+export declare class AssetDAMClient {
+    private readonly client;
+    constructor(client: StackShift);
+    spaces(): Promise<{
+        spaces: AssetSpaceAccess[];
+    }>;
+    collaborators(): Promise<{
+        collaborators: AssetCollaborator[];
+    }>;
+    invite(input: {
+        email: string;
+        actions: AssetAction[];
+        collection_id?: string;
+        expires_at: string;
+    }): Promise<AssetCollaborator>;
+    acceptInvitation(id: string): Promise<AssetCollaborator>;
+    updateCollaborator(id: string, revision: number, actions: AssetAction[]): Promise<{
+        saved: boolean;
+    }>;
+    revokeCollaborator(id: string, revision: number): Promise<{
+        saved: boolean;
+    }>;
+    metadataSchemas(): Promise<{
+        schemas: AssetMetadataSchema[];
+    }>;
+    metadataEditor(assetId: string): Promise<{
+        fields: AssetMetadataField[];
+        metadata: Record<string, unknown>;
+        revision: number;
+        metadata_revision: number;
+        can_edit: boolean;
+    }>;
+    createMetadataSchema(input: {
+        name: string;
+        fields: AssetMetadataField[];
+    }): Promise<AssetMetadataSchema>;
+    updateMetadataSchema(id: string, revision: number, input: {
+        name: string;
+        fields: AssetMetadataField[];
+    }): Promise<AssetMetadataSchema>;
+    publishMetadataSchema(id: string, revision: number): Promise<AssetMetadataSchema>;
+    bucketGovernance(id: string): Promise<AssetBucketGovernance>;
+    saveBucketGovernance(id: string, input: Omit<AssetBucketGovernance, 'bucket_id' | 'migrating'>): Promise<AssetBucketGovernance>;
+    migrateBucketGovernance(id: string, revision: number): Promise<AssetBucketGovernance>;
+    publications(options?: {
+        asset_id?: string;
+        status?: AssetPublicationStatus;
+        cursor?: string;
+    }): Promise<{
+        publications: AssetPublication[];
+        next_cursor: string;
+    }>;
+    publicationRenditions(assetId: string): Promise<{
+        renditions: AssetMediaReference[];
+    }>;
+    createPublication(input: AssetPublicationInput): Promise<AssetPublication>;
+    updatePublication(id: string, revision: number, input: AssetPublicationInput): Promise<AssetPublication>;
+    transitionPublication(id: string, revision: number, action: 'submit' | 'approve' | 'request-changes' | 'publish' | 'withdraw', note?: string): Promise<AssetPublication>;
+    resolvePublication(id: string, preview?: boolean): Promise<AssetPublicationDelivery>;
+    resolvePublicationAR(id: string): Promise<AssetPublicationDelivery>;
+    createPublicationARHandoff(id: string): Promise<{
+        handoff_url: string;
+        expires_at: string;
+    }>;
+    createPickerCapability(input: AssetPickerCapabilityInput): Promise<{
+        token: string;
+        capability: AssetPickerCapability;
+    }>;
+    revokePickerCapability(id: string): Promise<{
+        revoked: boolean;
+    }>;
+    models(assetId: string): Promise<{
+        packages: AssetModelPackage[];
+        pilot_enabled: boolean;
+        daily_jobs: number;
+        rendering: AssetRenderingInfo;
+    }>;
+    estimateRender(assetId: string, revision: number, input: AssetRenderInput): Promise<AssetRenderEstimate>;
+    renderProduct(assetId: string, revision: number, idempotencyKey: string, input: AssetRenderInput, maximumUnits: number): Promise<AssetRenderSubmission>;
+    processModel(assetId: string, revision: number, idempotencyKey: string): Promise<AssetJobSubmission>;
+    modelVariants(assetId: string): Promise<AssetModelVariant[]>;
+    createModelVariant(assetId: string, revision: number, input: AssetModelVariantInput): Promise<AssetModelVariant>;
+    updateModelVariant(assetId: string, variantId: string, revision: number, input: AssetModelVariantInput): Promise<AssetModelVariant>;
+    deleteModelVariant(assetId: string, variantId: string, assetRevision: number, variantRevision: number): Promise<{
+        deleted: boolean;
+    }>;
+    galleries(cursor?: string): Promise<{
+        galleries: AssetGallery[];
+        next_cursor: string;
+    }>;
+    createGallery(input: {
+        name: string;
+        entries: AssetGalleryEntryInput[];
+    }): Promise<AssetGallery>;
+    updateGallery(id: string, revision: number, input: {
+        name: string;
+        entries: AssetGalleryEntryInput[];
+    }): Promise<AssetGallery>;
+    transitionGallery(id: string, revision: number, action: 'publish' | 'withdraw'): Promise<AssetGallery>;
+    resolveGallery(id: string, preview?: boolean): Promise<AssetGalleryDelivery>;
+    resolveGalleryAR(id: string, publicationId: string): Promise<AssetPublicationDelivery>;
+}

package/dist/assets-dam.js

@@ -0,0 +1,52 @@
+const path = (group, id) => `/assets/${group}/${encodeURIComponent(id)}`;
+const revisionHeaders = (revision) => ({ 'If-Match': `"${revision}"` });
+export class AssetDAMClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    spaces() { return this.client.request('/assets/spaces'); }
+    collaborators() { return this.client.request('/assets/collaborators'); }
+    invite(input) { return this.client.request('/assets/collaborators', { method: 'POST', body: input }); }
+    acceptInvitation(id) { return this.client.request(`${path('invitations', id)}/accept`, { method: 'POST' }); }
+    updateCollaborator(id, revision, actions) { return this.client.request(path('collaborators', id), { method: 'PUT', headers: revisionHeaders(revision), body: { actions } }); }
+    revokeCollaborator(id, revision) { return this.client.request(path('collaborators', id), { method: 'DELETE', headers: revisionHeaders(revision) }); }
+    metadataSchemas() { return this.client.request('/assets/metadata-schemas'); }
+    metadataEditor(assetId) { return this.client.request(`/assets/${encodeURIComponent(assetId)}/metadata-editor`); }
+    createMetadataSchema(input) { return this.client.request('/assets/metadata-schemas', { method: 'POST', body: input }); }
+    updateMetadataSchema(id, revision, input) { return this.client.request(path('metadata-schemas', id), { method: 'PUT', headers: revisionHeaders(revision), body: input }); }
+    publishMetadataSchema(id, revision) { return this.client.request(`${path('metadata-schemas', id)}/publish`, { method: 'POST', headers: revisionHeaders(revision) }); }
+    bucketGovernance(id) { return this.client.request(`${path('buckets', id)}/governance`); }
+    saveBucketGovernance(id, input) { return this.client.request(`${path('buckets', id)}/governance`, { method: 'PUT', body: input }); }
+    migrateBucketGovernance(id, revision) { return this.client.request(`${path('buckets', id)}/governance/migrate`, { method: 'POST', headers: revisionHeaders(revision) }); }
+    publications(options = {}) {
+        const query = new URLSearchParams();
+        for (const [key, value] of Object.entries(options))
+            if (value)
+                query.set(key, value);
+        return this.client.request(`/assets/publications?${query}`);
+    }
+    publicationRenditions(assetId) { return this.client.request(`/assets/${encodeURIComponent(assetId)}/publication-renditions`); }
+    createPublication(input) { return this.client.request('/assets/publications', { method: 'POST', body: input }); }
+    updatePublication(id, revision, input) { return this.client.request(path('publications', id), { method: 'PUT', headers: revisionHeaders(revision), body: input }); }
+    transitionPublication(id, revision, action, note = '') { return this.client.request(`${path('publications', id)}/${action}`, { method: 'POST', headers: revisionHeaders(revision), body: { note } }); }
+    resolvePublication(id, preview = false) { return this.client.request(`${path('publications', id)}/${preview ? 'preview' : 'resolve'}`); }
+    resolvePublicationAR(id) { return this.client.request(`${path('publications', id)}/ar`, { method: 'POST' }); }
+    createPublicationARHandoff(id) { return this.client.request(`${path('publications', id)}/ar-handoff`, { method: 'POST' }); }
+    createPickerCapability(input) { return this.client.request('/assets/picker-capabilities', { method: 'POST', body: input }); }
+    revokePickerCapability(id) { return this.client.request(path('picker-capabilities', id), { method: 'DELETE' }); }
+    models(assetId) { return this.client.request(`/assets/${encodeURIComponent(assetId)}/models`); }
+    estimateRender(assetId, revision, input) { return this.client.request(`/assets/${encodeURIComponent(assetId)}/models`, { method: 'POST', headers: revisionHeaders(revision), body: { ...input, operation: 'estimate' } }); }
+    renderProduct(assetId, revision, idempotencyKey, input, maximumUnits) { return this.client.request(`/assets/${encodeURIComponent(assetId)}/models`, { method: 'POST', headers: { ...revisionHeaders(revision), 'Idempotency-Key': idempotencyKey }, body: { ...input, operation: 'render', maximum_units: maximumUnits } }); }
+    processModel(assetId, revision, idempotencyKey) { return this.client.request(`/assets/${encodeURIComponent(assetId)}/models`, { method: 'POST', headers: { ...revisionHeaders(revision), 'Idempotency-Key': idempotencyKey } }); }
+    modelVariants(assetId) { return this.client.request(`/assets/${encodeURIComponent(assetId)}/model-variants`); }
+    createModelVariant(assetId, revision, input) { return this.client.request(`/assets/${encodeURIComponent(assetId)}/model-variants`, { method: 'POST', headers: revisionHeaders(revision), body: input }); }
+    updateModelVariant(assetId, variantId, revision, input) { return this.client.request(`/assets/${encodeURIComponent(assetId)}/model-variants/${encodeURIComponent(variantId)}`, { method: 'PUT', headers: revisionHeaders(revision), body: input }); }
+    deleteModelVariant(assetId, variantId, assetRevision, variantRevision) { return this.client.request(`/assets/${encodeURIComponent(assetId)}/model-variants/${encodeURIComponent(variantId)}?revision=${variantRevision}`, { method: 'DELETE', headers: revisionHeaders(assetRevision) }); }
+    galleries(cursor) { return this.client.request(`/assets/galleries${cursor ? '?cursor=' + encodeURIComponent(cursor) : ''}`); }
+    createGallery(input) { return this.client.request('/assets/galleries', { method: 'POST', body: input }); }
+    updateGallery(id, revision, input) { return this.client.request(path('galleries', id), { method: 'PUT', headers: revisionHeaders(revision), body: input }); }
+    transitionGallery(id, revision, action) { return this.client.request(`${path('galleries', id)}/${action}`, { method: 'POST', headers: revisionHeaders(revision) }); }
+    resolveGallery(id, preview = false) { return this.client.request(`${path('galleries', id)}/resolve${preview ? '?preview=true' : ''}`); }
+    resolveGalleryAR(id, publicationId) { return this.client.request(`${path('galleries', id)}/ar`, { method: 'POST', body: { publication_id: publicationId } }); }
+}