@stackshift-cloud/sdk 1.1.0 → 1.2.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
@@ -276,7 +296,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 +327,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/assets-dam-types.d.ts

@@ -0,0 +1,225 @@
+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 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';
+export interface AssetRenderInput {
+    version_id: string;
+    source_checksum: string;
+    recipe: AssetRenderRecipe;
+    outputs: AssetRenderOutput[];
+}
+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[];
+    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,96 @@
+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, 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>;
+    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>;
+    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,47 @@
+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' }); }
+    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 } }); }
+    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 } }); }
+}

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

@@ -0,0 +1,116 @@
+export interface AssetVideoPackage {
+    id: string;
+    asset_space_id: string;
+    asset_id: string;
+    version_id: string;
+    source_checksum_sha256: string;
+    recipe_hash: string;
+    recipe: string;
+    processor_revision: string;
+    status: 'queued' | 'processing' | 'ready' | 'degraded' | 'failed' | 'cancelled';
+    phase: string;
+    progress_percent: number;
+    job_id?: string;
+    published_attempt?: string;
+    admitted_at?: string;
+    created_at: string;
+    updated_at: string;
+    failure_code: string;
+    metadata: {
+        asset_id: string;
+        duration_seconds: number;
+        width: number;
+        height: number;
+        codec: string;
+        bitrate: number;
+        frame_rate: number;
+        has_audio: boolean;
+        rotation: number;
+        created_at: string;
+        updated_at: string;
+    };
+}
+export interface AssetVideoWorkspace {
+    active?: AssetVideoPackage;
+    pending?: AssetVideoPackage;
+    source?: {
+        version_id: string;
+        scan_status: 'pending' | 'clean' | 'infected' | 'failed';
+        review_status: 'not_required' | 'pending' | 'approved' | 'rejected';
+        review_reason: string;
+    };
+    renditions: Array<{
+        id: string;
+        package_id?: string;
+        asset_id: string;
+        source_checksum_sha256: string;
+        kind: 'hls' | 'mp4' | 'poster';
+        profile: string;
+        width: number;
+        height: number;
+        size: number;
+        mime_type: string;
+        status: string;
+        created_at: string;
+        updated_at: string;
+    }>;
+    admission_enabled: boolean;
+}
+export interface AssetVideoCaptionInput {
+    /** Atomically replace this active track; the new reference receives a new ID. */
+    replace_caption_id?: string;
+    caption_asset_id: string;
+    caption_version_id: string;
+    language: string;
+    label: string;
+    kind: 'captions' | 'subtitles';
+    is_default?: boolean;
+}
+export interface AssetVideoCaption extends AssetVideoCaptionInput {
+    id: string;
+    asset_space_id: string;
+    asset_id: string;
+    version_id: string;
+    is_default: boolean;
+}
+export interface AssetPlaybackGrant {
+    has_audio: boolean;
+    session: {
+        id: string;
+        asset_space_id: string;
+        asset_id: string;
+        package_id: string;
+        version_id: string;
+        owner_id?: string;
+        is_private: boolean;
+        expires_at: string;
+        maximum_expires_at: string;
+        revoked_at?: string;
+        created_at: string;
+    };
+    credential: string;
+    hls: string;
+    mp4: string;
+    poster?: string;
+    captions: Array<{
+        id: string;
+        url: string;
+        language: string;
+        label: string;
+        kind: 'captions' | 'subtitles';
+        is_default: boolean;
+    }>;
+}
+export interface AssetPlaybackEvent {
+    sequence: number;
+    kind: 'startup' | 'rebuffer' | 'error' | 'quality' | 'watched' | 'completed';
+    value: number;
+}
+export interface AssetPlaybackAnalytics {
+    starts: number;
+    completions: number;
+    errors: number;
+    startup_ms: number;
+    rebuffer_ms: number;
+    watched_ms: number;
+}

package/dist/assets-video-types.js

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

package/dist/assets-video.d.ts

@@ -0,0 +1,25 @@
+import type { StackShift } from './client.js';
+import type { AssetVideoWorkspace, AssetVideoPackage, AssetVideoCaption, AssetVideoCaptionInput, AssetPlaybackGrant, AssetPlaybackEvent, AssetPlaybackAnalytics } from './assets-video-types.js';
+export declare class AssetVideoClient {
+    private readonly client;
+    constructor(client: StackShift);
+    workspace(assetId: string): Promise<AssetVideoWorkspace>;
+    process(assetId: string, versionId: string): Promise<AssetVideoPackage>;
+    createSession(assetId: string): Promise<AssetPlaybackGrant>;
+    renewSession(credential: string): Promise<AssetPlaybackGrant>;
+    revokeSession(assetId: string, sessionId: string): Promise<{
+        revoked: boolean;
+    }>;
+    captions(assetId: string, versionId: string): Promise<AssetVideoCaption[]>;
+    addCaption(assetId: string, versionId: string, input: AssetVideoCaptionInput): Promise<AssetVideoCaption>;
+    removeCaption(assetId: string, versionId: string, captionId: string): Promise<{
+        removed: boolean;
+    }>;
+    review(assetId: string, versionId: string, decision: 'approved' | 'rejected', reason: string): Promise<{
+        reviewed: boolean;
+    }>;
+    events(credential: string, events: AssetPlaybackEvent[]): Promise<{
+        accepted: boolean;
+    }>;
+    analytics(assetId: string): Promise<AssetPlaybackAnalytics>;
+}

package/dist/assets-video.js

@@ -0,0 +1,19 @@
+const assetPath = (id) => `/assets/${encodeURIComponent(id)}`;
+const versionPath = (id, version) => `${assetPath(id)}/versions/${encodeURIComponent(version)}/video`;
+export class AssetVideoClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    workspace(assetId) { return this.client.request(`${assetPath(assetId)}/video`); }
+    process(assetId, versionId) { return this.client.request(versionPath(assetId, versionId), { method: 'POST' }); }
+    createSession(assetId) { return this.client.request(`${assetPath(assetId)}/playback-sessions`, { method: 'POST' }); }
+    renewSession(credential) { return this.client.playbackRequest('/sessions/renew', credential, {}); }
+    revokeSession(assetId, sessionId) { return this.client.request(`${assetPath(assetId)}/playback-sessions/${encodeURIComponent(sessionId)}`, { method: 'DELETE' }); }
+    captions(assetId, versionId) { return this.client.request(`${versionPath(assetId, versionId)}/captions`); }
+    addCaption(assetId, versionId, input) { return this.client.request(`${versionPath(assetId, versionId)}/captions`, { method: 'POST', body: input }); }
+    removeCaption(assetId, versionId, captionId) { return this.client.request(`${versionPath(assetId, versionId)}/captions/${encodeURIComponent(captionId)}`, { method: 'DELETE' }); }
+    review(assetId, versionId, decision, reason) { return this.client.request(`${versionPath(assetId, versionId)}/review`, { method: 'POST', body: { decision, reason } }); }
+    events(credential, events) { return this.client.playbackRequest('/events', credential, { events }); }
+    analytics(assetId) { return this.client.request(`${assetPath(assetId)}/video/analytics`); }
+}

package/dist/assets.d.ts

@@ -1,3 +1,5 @@
+import { AssetDAMClient } from './assets-dam.js';
+import { AssetVideoClient } from './assets-video.js';
 import type { StackShift } from './client.js';
 import { AssetConnectionsClient, AssetMigrationsClient, AssetStorageClient, AssetTextClient, AssetUploadCapabilitiesClient } from './assets-platform.js';
 import { AssetWorkflowsClient } from './asset-workflows.js';
@@ -9,6 +11,8 @@ export declare function assetTransformOptions(preset: AssetTransformPreset): Ass
 export declare function assetTransformSpec(options: AssetTransformOptions): string;
 export declare class AssetsClient {
     private readonly client;
+    readonly dam: AssetDAMClient;
+    readonly video: AssetVideoClient;
     readonly connections: AssetConnectionsClient;
     readonly storage: AssetStorageClient;
     readonly migrations: AssetMigrationsClient;
@@ -79,7 +83,7 @@ export declare class AssetsClient {
         description?: string;
         asset_ids?: string[];
     }): Promise<AssetCollection>;
-    updateCollection(collectionId: string, input: {
+    updateCollection(collectionId: string, revision: number, input: {
         name: string;
         description?: string;
         asset_ids?: string[];