@stackshift-cloud/sdk 0.1.3 → 0.1.4

package/dist/assets-framework.d.ts

@@ -0,0 +1,21 @@
+import { AssetsClient } from './assets.js';
+import type { AssetSignedTransformOptions, AssetSignedUploadUrl, AssetTransformOptions } from './types.js';
+export interface ResponsiveImageOptions extends Omit<AssetSignedTransformOptions, 'width'> {
+    widths: number[];
+    sizes?: string;
+}
+export interface ResponsiveImageDescriptor {
+    src: string;
+    srcSet: string;
+    sizes: string;
+    widthUrls: Record<number, string>;
+}
+/** Shared by Next.js server actions, React/TanStack loaders, and NestJS services. */
+export declare function createResponsiveImage(assets: AssetsClient, assetId: string, options: ResponsiveImageOptions): Promise<ResponsiveImageDescriptor>;
+/** Uploads through a short-lived session without exposing the account API key. */
+export declare function uploadBrowserFile(session: AssetSignedUploadUrl, file: Blob, fetcher?: typeof fetch): Promise<Response>;
+export declare function namedResponsiveSource(assets: AssetsClient, assetId: string, preset: string, widths: number[]): string;
+export type ArtDirectionSource = {
+    media: string;
+    transform: AssetTransformOptions;
+};

package/dist/assets-framework.js

@@ -0,0 +1,34 @@
+/** Shared by Next.js server actions, React/TanStack loaders, and NestJS services. */
+export async function createResponsiveImage(assets, assetId, options) {
+    const widths = [...new Set(options.widths)].filter((width) => Number.isSafeInteger(width) && width > 0).sort((a, b) => a - b);
+    if (widths.length === 0 || widths.length > 12)
+        throw new Error('Responsive images require 1-12 positive integer widths');
+    const { widths: _widths, sizes = '100vw', ...transform } = options;
+    const signed = await Promise.all(widths.map(async (width) => [width, await assets.signedTransformUrl(assetId, { ...transform, width })]));
+    const widthUrls = Object.fromEntries(signed.map(([width, result]) => [width, result.url]));
+    return {
+        src: widthUrls[widths[widths.length - 1]],
+        srcSet: widths.map((width) => `${widthUrls[width]} ${width}w`).join(', '),
+        sizes,
+        widthUrls,
+    };
+}
+/** Uploads through a short-lived session without exposing the account API key. */
+export async function uploadBrowserFile(session, file, fetcher = fetch) {
+    if (session.method !== 'PUT')
+        throw new Error(`Unsupported upload method: ${session.method}`);
+    if (file.size > session.max_bytes)
+        throw new Error(`File exceeds signed upload limit of ${session.max_bytes} bytes`);
+    const response = await fetcher(session.url, {
+        method: session.method,
+        body: file,
+        headers: file.type ? { 'Content-Type': file.type } : undefined,
+    });
+    if (!response.ok)
+        throw new Error(`StackShift browser upload failed with HTTP ${response.status}`);
+    return response;
+}
+export function namedResponsiveSource(assets, assetId, preset, widths) {
+    const clean = [...new Set(widths)].filter((width) => Number.isSafeInteger(width) && width > 0).sort((a, b) => a - b);
+    return clean.map((width) => `${assets.namedUrl(assetId, `${preset}-${width}`)} ${width}w`).join(', ');
+}

package/dist/assets.d.ts

@@ -1,5 +1,5 @@
 import type { StackShift } from './client.js';
-import type { Asset, AssetAIInfo, AssetCollection, AssetContentPolicy, AssetNamedTransformInput, AssetListOptions, AssetListResult, AssetSavedSearch, AssetTranscript, AssetUploadProgressCallbacks, AssetVersion, AssetSignedUploadUrl, AssetSignedUploadUrlOptions, AssetSignedTransformOptions, AssetSignedUrl, AssetSignedUrlOptions, AssetTransformOptions, AssetTransformPreset, AssetUploadOptions } from './types.js';
+import type { Asset, AssetBucket, AssetBucketInput, AssetAIAccountConfig, AssetPatchInput, AssetCustomDomain, AssetEvent, AssetJob, AssetJobSubmission, AssetLifecycleRule, AssetUsageSummary, AssetWebhook, AssetWebhookDelivery, AssetAIInfo, AssetCollection, AssetContentPolicy, AssetNamedTransformInput, AssetListOptions, AssetListResult, AssetSavedSearch, AssetTranscript, AssetUploadProgressCallbacks, AssetVersion, AssetSignedUploadUrl, AssetSignedUploadUrlOptions, AssetSignedTransformOptions, AssetSignedUrl, AssetSignedUrlOptions, AssetTransformOptions, AssetTransformPreset, AssetUploadOptions } from './types.js';
 export declare const assetTransformPresets: AssetTransformPreset[];
 export declare function getAssetTransformPreset(name: string): AssetTransformPreset | undefined;
 export declare function assetTransformOptions(preset: AssetTransformPreset): AssetTransformOptions;
@@ -10,10 +10,8 @@ export declare class AssetsClient {
     upload(file: Blob, options?: AssetUploadOptions): Promise<Asset>;
     list(options?: AssetListOptions): Promise<AssetListResult>;
     get(assetId: string): Promise<Asset>;
-    delete(assetId: string): Promise<{
-        deleted: boolean;
-    }>;
-    replace(assetId: string, file: Blob, options?: Pick<AssetUploadOptions, 'cacheControl' | 'metadata'>): Promise<Asset>;
+    delete(assetId: string, revision: number, idempotencyKey?: string): Promise<AssetJobSubmission>;
+    replace(assetId: string, revision: number, file: Blob, options?: Pick<AssetUploadOptions, 'cacheControl' | 'metadata'>): Promise<Asset>;
     signedUrl(assetId: string, options: AssetSignedUrlOptions): Promise<AssetSignedUrl>;
     signedUploadUrl(options?: AssetSignedUploadUrlOptions): Promise<AssetSignedUploadUrl>;
     createUploadSession(options?: AssetSignedUploadUrlOptions): Promise<AssetSignedUploadUrl>;
@@ -24,29 +22,36 @@ export declare class AssetsClient {
     cancelUploadSession(sessionId: string): Promise<{
         cancelled: boolean;
     }>;
+    listBuckets(): Promise<{
+        buckets: AssetBucket[];
+    }>;
+    createBucket(input: AssetBucketInput & {
+        name: string;
+    }): Promise<AssetBucket>;
+    updateBucket(bucketId: string, revision: number, input: AssetBucketInput): Promise<AssetBucket>;
+    deleteBucket(bucketId: string, revision: number): Promise<void>;
+    setTags(assetId: string, revision: number, tags: string[]): Promise<{
+        tags: string[];
+        revision: number;
+    }>;
+    patchMetadata(assetId: string, revision: number, metadata: Record<string, unknown>): Promise<{
+        updated: boolean;
+        revision: number;
+    }>;
+    patch(assetId: string, revision: number, input: AssetPatchInput): Promise<Asset>;
     uploadWithProgress(file: Blob, options?: AssetSignedUploadUrlOptions, callbacks?: AssetUploadProgressCallbacks): Promise<Asset | AssetSignedUploadUrl>;
     url(assetId: string, options: AssetTransformOptions): string;
     namedUrl(assetId: string, name: string): string;
-    videoUrl(assetId: string, kind: 'hls' | 'poster' | 'mp4', profile?: string, token?: string): string;
+    videoUrl(assetId: string, kind: 'hls' | 'poster' | 'thumbnail' | 'mp4', profile?: string, token?: string): string;
     versionUrl(assetId: string, versionId: string, token?: string): string;
     branchUrl(assetId: string, branch: string, token?: string): string;
     ai(assetId: string): Promise<AssetAIInfo>;
-    analyze(assetId: string): Promise<{
-        analysis_queued: boolean;
-    }>;
-    moderate(assetId: string): Promise<{
-        moderation_queued: boolean;
-    }>;
+    analyze(assetId: string, idempotencyKey?: string): Promise<AssetJobSubmission>;
+    moderate(assetId: string, idempotencyKey?: string): Promise<AssetJobSubmission>;
     transcript(assetId: string): Promise<AssetTranscript>;
-    requestTranscript(assetId: string): Promise<{
-        transcript_queued: boolean;
-    }>;
-    requestSmartCrop(assetId: string): Promise<{
-        smart_crop_queued: boolean;
-    }>;
-    requestBackgroundRemoval(assetId: string): Promise<{
-        background_remove_queued: boolean;
-    }>;
+    requestTranscript(assetId: string, idempotencyKey?: string): Promise<AssetJobSubmission>;
+    requestSmartCrop(assetId: string, idempotencyKey?: string): Promise<AssetJobSubmission>;
+    requestBackgroundRemoval(assetId: string, idempotencyKey?: string): Promise<AssetJobSubmission>;
     versions(assetId: string): Promise<{
         versions: AssetVersion[];
     }>;
@@ -95,6 +100,66 @@ export declare class AssetsClient {
         deleted: boolean;
     }>;
     signedTransformUrl(assetId: string, options: AssetSignedTransformOptions): Promise<AssetSignedUrl>;
+    getAIConfig(): Promise<AssetAIAccountConfig>;
+    updateAIConfig(revision: number, enabledActions: string[], monthlySpendCapMicros: number): Promise<import("./types.js").AssetAIPolicy>;
+    job(jobId: string): Promise<AssetJob>;
+    cancelJob(jobId: string): Promise<AssetJob>;
+    createLifecycleRule(input: {
+        name: string;
+        prefix?: string;
+        action: 'delete' | 'expire_versions';
+        age_days: number;
+        enabled?: boolean;
+    }): Promise<AssetLifecycleRule>;
+    listLifecycleRules(): Promise<{
+        lifecycle_rules: AssetLifecycleRule[];
+    }>;
+    deleteLifecycleRule(ruleId: string): Promise<{
+        deleted: boolean;
+    }>;
+    createDomain(domain: string): Promise<AssetCustomDomain>;
+    listDomains(): Promise<{
+        domains: AssetCustomDomain[];
+    }>;
+    verifyDomain(domainId: string): Promise<AssetCustomDomain>;
+    deleteDomain(domainId: string): Promise<{
+        deleted: boolean;
+    }>;
+    analytics(): Promise<AssetUsageSummary>;
+    usageSummary(): Promise<AssetUsageSummary>;
+    events(limit?: number): Promise<{
+        events: AssetEvent[];
+        total: number;
+    }>;
+    createWebhook(url: string, eventTypes?: string[]): Promise<{
+        webhook: AssetWebhook;
+        secret: string;
+    }>;
+    listWebhooks(): Promise<{
+        webhooks: AssetWebhook[];
+    }>;
+    deleteWebhook(webhookId: string): Promise<{
+        deleted: boolean;
+    }>;
+    listWebhookDeliveries(webhookId: string, limit?: number): Promise<{
+        deliveries: AssetWebhookDelivery[];
+    }>;
+    retryWebhookDelivery(deliveryId: string): Promise<AssetWebhookDelivery>;
+    purge(assetId: string): Promise<{
+        purged: boolean;
+        asset_id: string;
+    }>;
+    bulk(input: {
+        action: 'delete' | 'visibility' | 'add_tags';
+        items: Array<{
+            asset_id: string;
+            revision: number;
+        }>;
+        visibility?: string;
+        tags?: string[];
+        idempotencyKey?: string;
+    }): Promise<AssetJobSubmission>;
     private originBaseUrl;
+    private requestAssetJob;
     private uploadSingleWithProgress;
 }

package/dist/assets.js

@@ -57,10 +57,17 @@ export class AssetsClient {
         append(query, 'visibility', options.visibility);
         append(query, 'query', options.query);
         append(query, 'tag', options.tag);
-        append(query, 'mimeType', options.mimeType);
+        append(query, 'mime_type', options.mimeType);
         append(query, 'type', options.type);
         append(query, 'folder', options.folder);
         append(query, 'checksum', options.checksum);
+        append(query, 'status', options.status);
+        append(query, 'scan_status', options.scanStatus);
+        append(query, 'replication_status', options.replicationStatus);
+        append(query, 'moderation_status', options.moderationStatus);
+        append(query, 'quarantine_status', options.quarantineStatus);
+        append(query, 'sort', options.sort);
+        append(query, 'direction', options.direction);
         append(query, 'limit', options.limit);
         append(query, 'cursor', options.cursor);
         const suffix = query.toString();
@@ -69,23 +76,25 @@ export class AssetsClient {
     get(assetId) {
         return this.client.request(`/assets/${encodeURIComponent(assetId)}`);
     }
-    delete(assetId) {
+    delete(assetId, revision, idempotencyKey) {
         return this.client.request(`/assets/${encodeURIComponent(assetId)}`, {
             method: 'DELETE',
+            headers: { 'If-Match': `"${revision}"`, ...(idempotencyKey ? { 'Idempotency-Key': idempotencyKey } : {}) },
         });
     }
-    replace(assetId, file, options = {}) {
+    replace(assetId, revision, file, options = {}) {
         return this.client.request(`/assets/${encodeURIComponent(assetId)}/replace`, {
             method: 'PUT',
             body: assetForm(file, options),
+            headers: { 'If-Match': `"${revision}"` },
         });
     }
     signedUrl(assetId, options) {
         return this.client.request(`/assets/${encodeURIComponent(assetId)}/signed-url`, {
             method: 'POST',
             body: {
-                expiresIn: options.expiresIn,
-                maxDownloads: options.maxDownloads,
+                expires_in: options.expiresIn,
+                max_downloads: options.maxDownloads,
             },
         });
     }
@@ -95,32 +104,33 @@ export class AssetsClient {
     createUploadSession(options = {}) {
         return this.client.request('/assets/upload-sessions', {
             method: 'POST',
+            headers: options.idempotencyKey ? { 'Idempotency-Key': options.idempotencyKey } : undefined,
             body: {
                 bucket: options.bucket,
                 key: options.key,
                 folder: options.folder,
                 visibility: options.visibility,
-                cacheControl: options.cacheControl,
+                cache_control: options.cacheControl,
                 metadata: options.metadata,
                 mode: options.mode,
-                fileName: options.fileName,
-                fileSize: options.fileSize,
-                mimeType: options.mimeType,
-                checksumSHA256: options.checksumSHA256,
-                partSize: options.partSize,
-                expiresIn: options.expiresIn,
-                maxBytes: options.maxBytes,
+                file_name: options.fileName,
+                file_size: options.fileSize,
+                mime_type: options.mimeType,
+                checksum_sha256: options.checksumSHA256,
+                part_size: options.partSize,
+                expires_in: options.expiresIn,
+                max_bytes: options.maxBytes,
             },
         });
     }
     createChunkedUploadSession(options) {
         return this.createUploadSession({ ...options, mode: 'chunked' });
     }
-    uploadChunk(uploadUrlOrToken, partNumber, chunk, callbacks = {}) {
+    async uploadChunk(uploadUrlOrToken, partNumber, chunk, callbacks = {}) {
         const target = uploadUrlOrToken.startsWith('http')
             ? `${uploadUrlOrToken.replace(/\/$/, '')}/parts/${partNumber}`
             : `${this.originBaseUrl()}/uploads/${encodeURIComponent(uploadUrlOrToken)}/parts/${partNumber}`;
-        return uploadBlob(target, chunk, callbacks, partNumber);
+        return uploadBlob(target, chunk, callbacks, partNumber, { 'X-Content-SHA256': await sha256Blob(chunk) });
     }
     resumeUploadSession(sessionId) {
         return this.client.request(`/assets/upload-sessions/${encodeURIComponent(sessionId)}`);
@@ -135,25 +145,101 @@ export class AssetsClient {
             method: 'DELETE',
         });
     }
+    listBuckets() {
+        return this.client.request('/assets/buckets');
+    }
+    createBucket(input) {
+        return this.client.request('/assets/buckets', { method: 'POST', body: input });
+    }
+    updateBucket(bucketId, revision, input) {
+        return this.client.request(`/assets/buckets/${encodeURIComponent(bucketId)}`, {
+            method: 'PUT', body: input, headers: { 'If-Match': `"${revision}"` },
+        });
+    }
+    deleteBucket(bucketId, revision) {
+        return this.client.request(`/assets/buckets/${encodeURIComponent(bucketId)}`, {
+            method: 'DELETE', headers: { 'If-Match': `"${revision}"` },
+        });
+    }
+    setTags(assetId, revision, tags) {
+        return this.client.request(`/assets/${encodeURIComponent(assetId)}/tags`, {
+            method: 'PUT', body: { tags }, headers: { 'If-Match': `"${revision}"` },
+        });
+    }
+    patchMetadata(assetId, revision, metadata) {
+        return this.client.request(`/assets/${encodeURIComponent(assetId)}/metadata`, {
+            method: 'PATCH', body: { metadata }, headers: { 'If-Match': `"${revision}"` },
+        });
+    }
+    patch(assetId, revision, input) {
+        return this.client.request(`/assets/${encodeURIComponent(assetId)}`, {
+            method: 'PATCH', body: input, headers: { 'If-Match': `"${revision}"` },
+        });
+    }
     async uploadWithProgress(file, options = {}, callbacks = {}) {
         const size = options.fileSize ?? file.size;
         if (size <= defaultPartSize) {
             return this.uploadSingleWithProgress(file, options, callbacks);
         }
-        const session = await this.createChunkedUploadSession({
-            ...options,
-            fileSize: size,
-            fileName: options.fileName ?? blobName(file),
-            mimeType: options.mimeType ?? file.type,
-        });
+        throwIfAborted(callbacks.signal);
+        const session = options.uploadSessionId
+            ? await this.resumeUploadSession(options.uploadSessionId)
+            : await this.createChunkedUploadSession({
+                ...options,
+                fileSize: size,
+                fileName: options.fileName ?? blobName(file),
+                mimeType: options.mimeType ?? file.type,
+            });
         const partSize = session.part_size ?? defaultPartSize;
+        const sessionId = session.session_id ?? options.uploadSessionId;
+        if (!sessionId) {
+            throw new Error('Chunked upload session did not include a resumable session id');
+        }
+        const completed = new Map((session.parts ?? []).map((part) => [part.part_number, part.size]));
+        const loadedByPart = new Map(completed);
+        const tasks = [];
         for (let offset = 0, part = 1; offset < size; offset += partSize, part += 1) {
-            await this.uploadChunk(session.upload_session_id, part, file.slice(offset, offset + partSize), callbacks);
+            if (!completed.has(part))
+                tasks.push({ part, chunk: file.slice(offset, offset + partSize) });
         }
-        if (!session.session_id) {
-            throw new Error('Chunked upload session did not include a resumable session id');
+        const reportProgress = () => {
+            const loaded = Math.min(size, Array.from(loadedByPart.values()).reduce((sum, value) => sum + value, 0));
+            callbacks.onProgress?.({ loaded, total: size, percent: size ? Math.round((loaded / size) * 100) : 100 });
+        };
+        reportProgress();
+        const concurrency = boundedInteger(options.concurrency, 4, 1, 8);
+        const attempts = boundedInteger(options.retryAttempts, 4, 1, 8);
+        let next = 0;
+        const worker = async () => {
+            while (next < tasks.length) {
+                throwIfAborted(callbacks.signal);
+                const task = tasks[next++];
+                await retryWithBackoff(async () => {
+                    throwIfAborted(callbacks.signal);
+                    await this.uploadChunk(session.upload_session_id, task.part, task.chunk, {
+                        signal: callbacks.signal,
+                        onProgress: (progress) => {
+                            loadedByPart.set(task.part, progress.loaded);
+                            callbacks.onPartProgress?.(task.part, progress);
+                            reportProgress();
+                        },
+                    });
+                    loadedByPart.set(task.part, task.chunk.size);
+                    reportProgress();
+                }, attempts, callbacks.signal);
+            }
+        };
+        try {
+            await Promise.all(Array.from({ length: Math.min(concurrency, tasks.length || 1) }, worker));
+            throwIfAborted(callbacks.signal);
+            return await retryWithBackoff(() => this.completeUploadSession(sessionId), attempts, callbacks.signal);
+        }
+        catch (error) {
+            if (isAbortError(error)) {
+                await this.cancelUploadSession(sessionId).catch(() => undefined);
+            }
+            throw error;
         }
-        return this.completeUploadSession(session.session_id);
     }
     url(assetId, options) {
         return `${this.client.cdnBaseUrl}/assets/${encodeURIComponent(assetId)}/tr/${encodeURIComponent(transformSpec(options))}`;
@@ -188,23 +274,23 @@ export class AssetsClient {
     ai(assetId) {
         return this.client.request(`/assets/${encodeURIComponent(assetId)}/ai`);
     }
-    analyze(assetId) {
-        return this.client.request(`/assets/${encodeURIComponent(assetId)}/ai/analyze`, { method: 'POST' });
+    analyze(assetId, idempotencyKey) {
+        return this.requestAssetJob(`/assets/${encodeURIComponent(assetId)}/ai/analyze`, idempotencyKey);
     }
-    moderate(assetId) {
-        return this.client.request(`/assets/${encodeURIComponent(assetId)}/moderation`, { method: 'POST' });
+    moderate(assetId, idempotencyKey) {
+        return this.requestAssetJob(`/assets/${encodeURIComponent(assetId)}/moderation`, idempotencyKey);
     }
     transcript(assetId) {
         return this.client.request(`/assets/${encodeURIComponent(assetId)}/transcript`);
     }
-    requestTranscript(assetId) {
-        return this.client.request(`/assets/${encodeURIComponent(assetId)}/transcript`, { method: 'POST' });
+    requestTranscript(assetId, idempotencyKey) {
+        return this.requestAssetJob(`/assets/${encodeURIComponent(assetId)}/transcript`, idempotencyKey);
     }
-    requestSmartCrop(assetId) {
-        return this.client.request(`/assets/${encodeURIComponent(assetId)}/smart-crop`, { method: 'POST' });
+    requestSmartCrop(assetId, idempotencyKey) {
+        return this.requestAssetJob(`/assets/${encodeURIComponent(assetId)}/smart-crop`, idempotencyKey);
     }
-    requestBackgroundRemoval(assetId) {
-        return this.client.request(`/assets/${encodeURIComponent(assetId)}/background-remove`, { method: 'POST' });
+    requestBackgroundRemoval(assetId, idempotencyKey) {
+        return this.requestAssetJob(`/assets/${encodeURIComponent(assetId)}/background-remove`, idempotencyKey);
     }
     versions(assetId) {
         return this.client.request(`/assets/${encodeURIComponent(assetId)}/versions`);
@@ -274,9 +360,81 @@ export class AssetsClient {
             body: transformBody(options),
         });
     }
+    getAIConfig() {
+        return this.client.request('/assets/ai/config');
+    }
+    updateAIConfig(revision, enabledActions, monthlySpendCapMicros) {
+        return this.client.request('/assets/ai/config', {
+            method: 'PUT', headers: { 'If-Match': `"${revision}"` },
+            body: { enabled_actions: enabledActions, monthly_spend_cap_micros: monthlySpendCapMicros },
+        });
+    }
+    job(jobId) {
+        return this.client.request(`/assets/jobs/${encodeURIComponent(jobId)}`);
+    }
+    cancelJob(jobId) {
+        return this.client.request(`/assets/jobs/${encodeURIComponent(jobId)}/cancel`, { method: 'POST' });
+    }
+    createLifecycleRule(input) {
+        return this.client.request('/assets/lifecycle-rules', { method: 'POST', body: input });
+    }
+    listLifecycleRules() {
+        return this.client.request('/assets/lifecycle-rules');
+    }
+    deleteLifecycleRule(ruleId) {
+        return this.client.request(`/assets/lifecycle-rules/${encodeURIComponent(ruleId)}`, { method: 'DELETE' });
+    }
+    createDomain(domain) {
+        return this.client.request('/assets/domains', { method: 'POST', body: { domain } });
+    }
+    listDomains() {
+        return this.client.request('/assets/domains');
+    }
+    verifyDomain(domainId) {
+        return this.client.request(`/assets/domains/${encodeURIComponent(domainId)}/verify`, { method: 'POST' });
+    }
+    deleteDomain(domainId) {
+        return this.client.request(`/assets/domains/${encodeURIComponent(domainId)}`, { method: 'DELETE' });
+    }
+    analytics() {
+        return this.client.request('/assets/analytics');
+    }
+    usageSummary() {
+        return this.client.request('/assets/summary');
+    }
+    events(limit = 50) {
+        return this.client.request(`/assets/events?limit=${limit}`);
+    }
+    createWebhook(url, eventTypes = ['asset.*']) {
+        return this.client.request('/assets/webhooks', {
+            method: 'POST', body: { url, event_types: eventTypes },
+        });
+    }
+    listWebhooks() {
+        return this.client.request('/assets/webhooks');
+    }
+    deleteWebhook(webhookId) {
+        return this.client.request(`/assets/webhooks/${encodeURIComponent(webhookId)}`, { method: 'DELETE' });
+    }
+    listWebhookDeliveries(webhookId, limit = 50) {
+        return this.client.request(`/assets/webhooks/${encodeURIComponent(webhookId)}/deliveries?limit=${limit}`);
+    }
+    retryWebhookDelivery(deliveryId) {
+        return this.client.request(`/assets/webhook-deliveries/${encodeURIComponent(deliveryId)}/retry`, { method: 'POST' });
+    }
+    purge(assetId) {
+        return this.client.request(`/assets/${encodeURIComponent(assetId)}/purge`, { method: 'POST' });
+    }
+    bulk(input) {
+        const { idempotencyKey, ...body } = input;
+        return this.client.request('/assets/bulk', { method: 'POST', body, headers: idempotencyKey ? { 'Idempotency-Key': idempotencyKey } : undefined });
+    }
     originBaseUrl() {
         return this.client.baseUrl.replace(/\/api\/v1$/, '');
     }
+    requestAssetJob(path, idempotencyKey) {
+        return this.client.request(path, { method: 'POST', headers: idempotencyKey ? { 'Idempotency-Key': idempotencyKey } : undefined });
+    }
     async uploadSingleWithProgress(file, options, callbacks) {
         const session = await this.createUploadSession({
             ...options,
@@ -294,7 +452,7 @@ function assetForm(file, options) {
     append(body, 'key', options.key);
     append(body, 'folder', options.folder);
     append(body, 'visibility', options.visibility);
-    append(body, 'cacheControl', options.cacheControl);
+    append(body, 'cache_control', options.cacheControl);
     if (options.metadata) {
         body.append('metadata', JSON.stringify(options.metadata));
     }
@@ -314,6 +472,8 @@ function transformSpec(options) {
     parts.push(`c_${options.crop ?? 'fit'}`);
     parts.push(`f_${options.format ?? 'auto'}`);
     parts.push(`q_${options.quality ?? 'auto'}`);
+    parts.push(`g_${options.gravity ?? 'centre'}`);
+    parts.push(`a_${options.animation ?? 'first'}`);
     return parts.join(',');
 }
 function preset(name, category, description, width, height, crop = 'fit', format = 'auto', quality = 'auto') {
@@ -326,23 +486,33 @@ function transformBody(options) {
         crop: options.crop,
         format: options.format,
         quality: options.quality,
-        expiresIn: options.expiresIn,
+        gravity: options.gravity,
+        animation: options.animation,
+        expires_in: options.expiresIn,
     };
 }
 const defaultPartSize = 5 * 1024 * 1024;
 function blobName(file) {
     return file.name;
 }
-function uploadBlob(url, blob, callbacks, partNumber) {
+function uploadBlob(url, blob, callbacks, partNumber, headers = {}) {
     if (typeof XMLHttpRequest === 'undefined') {
-        return fetch(url, { method: 'PUT', body: blob }).then((response) => {
+        return fetch(url, { method: 'PUT', body: blob, signal: callbacks.signal, headers }).then((response) => {
             if (!response.ok)
                 throw new Error(`Upload failed with ${response.status}`);
+            const progress = { loaded: blob.size, total: blob.size, percent: 100 };
+            callbacks.onProgress?.(progress);
+            if (partNumber)
+                callbacks.onPartProgress?.(partNumber, progress);
         });
     }
     return new Promise((resolve, reject) => {
         const xhr = new XMLHttpRequest();
         xhr.open('PUT', url);
+        for (const [name, value] of Object.entries(headers))
+            xhr.setRequestHeader(name, value);
+        const abort = () => xhr.abort();
+        callbacks.signal?.addEventListener('abort', abort, { once: true });
         xhr.upload.onprogress = (event) => {
             const total = event.total || blob.size;
             const progress = { loaded: event.loaded, total, percent: total ? Math.round((event.loaded / total) * 100) : 0 };
@@ -350,13 +520,64 @@ function uploadBlob(url, blob, callbacks, partNumber) {
             if (partNumber)
                 callbacks.onPartProgress?.(partNumber, progress);
         };
+        const cleanup = () => callbacks.signal?.removeEventListener('abort', abort);
         xhr.onload = () => {
+            cleanup();
             if (xhr.status >= 200 && xhr.status < 300)
                 resolve();
             else
                 reject(new Error(`Upload failed with ${xhr.status}`));
         };
-        xhr.onerror = () => reject(new Error('Upload failed'));
+        xhr.onerror = () => { cleanup(); reject(new Error('Upload failed')); };
+        xhr.onabort = () => { cleanup(); reject(abortError()); };
         xhr.send(blob);
     });
 }
+async function sha256Blob(blob) {
+    if (!globalThis.crypto?.subtle)
+        throw new Error('Web Crypto SHA-256 is required for multipart uploads');
+    const digest = await globalThis.crypto.subtle.digest('SHA-256', await blob.arrayBuffer());
+    return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, '0')).join('');
+}
+function boundedInteger(value, fallback, minimum, maximum) {
+    if (value === undefined)
+        return fallback;
+    if (!Number.isSafeInteger(value))
+        throw new Error('Upload concurrency and retry attempts must be integers');
+    return Math.min(maximum, Math.max(minimum, value));
+}
+async function retryWithBackoff(operation, attempts, signal) {
+    let lastError;
+    for (let attempt = 0; attempt < attempts; attempt += 1) {
+        try {
+            return await operation();
+        }
+        catch (error) {
+            if (isAbortError(error) || signal?.aborted)
+                throw abortError();
+            lastError = error;
+            if (attempt + 1 < attempts)
+                await abortableDelay(250 * 2 ** attempt, signal);
+        }
+    }
+    throw lastError;
+}
+function abortableDelay(milliseconds, signal) {
+    throwIfAborted(signal);
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => { cleanup(); resolve(); }, milliseconds);
+        const abort = () => { clearTimeout(timer); cleanup(); reject(abortError()); };
+        const cleanup = () => signal?.removeEventListener('abort', abort);
+        signal?.addEventListener('abort', abort, { once: true });
+    });
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted)
+        throw abortError();
+}
+function abortError() {
+    return typeof DOMException === 'undefined' ? Object.assign(new Error('Upload cancelled'), { name: 'AbortError' }) : new DOMException('Upload cancelled', 'AbortError');
+}
+function isAbortError(error) {
+    return error instanceof Error && error.name === 'AbortError';
+}

package/dist/generated/assets-contract.d.ts

@@ -0,0 +1,329 @@
+export type AssetOperationId = 'uploadAsset' | 'createUploadSession' | 'getUploadSession' | 'completeUploadSession' | 'cancelUploadSession' | 'createSignedUploadUrl' | 'createBucket' | 'listBuckets' | 'updateBucket' | 'deleteBucket' | 'getContentPolicy' | 'updateContentPolicy' | 'upsertTransformation' | 'listTransformations' | 'deleteTransformation' | 'createLifecycleRule' | 'listLifecycleRules' | 'deleteLifecycleRule' | 'createDomain' | 'listDomains' | 'verifyDomain' | 'deleteDomain' | 'getAnalytics' | 'getUsageSummary' | 'listEvents' | 'createWebhook' | 'listWebhooks' | 'deleteWebhook' | 'listWebhookDeliveries' | 'retryWebhookDelivery' | 'bulkAssets' | 'listCollections' | 'createCollection' | 'updateCollection' | 'deleteCollection' | 'listSavedSearches' | 'createSavedSearch' | 'updateSavedSearch' | 'deleteSavedSearch' | 'getAIConfig' | 'updateAIConfig' | 'getJob' | 'cancelJob' | 'listAssets' | 'getAsset' | 'patchAsset' | 'getAssetAI' | 'analyzeAsset' | 'moderateAsset' | 'getTranscript' | 'transcribeAsset' | 'smartCropAsset' | 'removeAssetBackground' | 'listAssetVersions' | 'createAssetBranch' | 'restoreAssetVersion' | 'promoteAssetBranch' | 'deleteAsset' | 'replaceAsset' | 'createSignedAssetUrl' | 'createSignedTransformUrl' | 'setAssetTags' | 'patchAssetMetadata' | 'purgeAsset';
+export type AssetAPIScope = 'assets:read' | 'assets:write' | 'assets:process' | 'assets:admin';
+export interface AssetContractOperation {
+    readonly id: AssetOperationId;
+    readonly method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    readonly path: string;
+    readonly scope: AssetAPIScope;
+}
+export declare const assetContractOperations: readonly [{
+    readonly id: "uploadAsset";
+    readonly method: "POST";
+    readonly path: "/api/v1/assets/upload";
+    readonly scope: "assets:write";
+}, {
+    readonly id: "createUploadSession";
+    readonly method: "POST";
+    readonly path: "/api/v1/assets/upload-sessions";
+    readonly scope: "assets:write";
+}, {
+    readonly id: "getUploadSession";
+    readonly method: "GET";
+    readonly path: "/api/v1/assets/upload-sessions/{sessionID}";
+    readonly scope: "assets:read";
+}, {
+    readonly id: "completeUploadSession";
+    readonly method: "POST";
+    readonly path: "/api/v1/assets/upload-sessions/{sessionID}/complete";
+    readonly scope: "assets:write";
+}, {
+    readonly id: "cancelUploadSession";
+    readonly method: "DELETE";
+    readonly path: "/api/v1/assets/upload-sessions/{sessionID}";
+    readonly scope: "assets:write";
+}, {
+    readonly id: "createSignedUploadUrl";
+    readonly method: "POST";
+    readonly path: "/api/v1/assets/upload-url";
+    readonly scope: "assets:write";
+}, {
+    readonly id: "createBucket";
+    readonly method: "POST";
+    readonly path: "/api/v1/assets/buckets";
+    readonly scope: "assets:admin";
+}, {
+    readonly id: "listBuckets";
+    readonly method: "GET";
+    readonly path: "/api/v1/assets/buckets";
+    readonly scope: "assets:read";
+}, {
+    readonly id: "updateBucket";
+    readonly method: "PUT";
+    readonly path: "/api/v1/assets/buckets/{bucketID}";
+    readonly scope: "assets:admin";
+}, {
+    readonly id: "deleteBucket";
+    readonly method: "DELETE";
+    readonly path: "/api/v1/assets/buckets/{bucketID}";
+    readonly scope: "assets:admin";
+}, {
+    readonly id: "getContentPolicy";
+    readonly method: "GET";
+    readonly path: "/api/v1/assets/policy";
+    readonly scope: "assets:read";
+}, {
+    readonly id: "updateContentPolicy";
+    readonly method: "PUT";
+    readonly path: "/api/v1/assets/policy";
+    readonly scope: "assets:admin";
+}, {
+    readonly id: "upsertTransformation";
+    readonly method: "POST";
+    readonly path: "/api/v1/assets/transformations";
+    readonly scope: "assets:process";
+}, {
+    readonly id: "listTransformations";
+    readonly method: "GET";
+    readonly path: "/api/v1/assets/transformations";
+    readonly scope: "assets:read";
+}, {
+    readonly id: "deleteTransformation";
+    readonly method: "DELETE";
+    readonly path: "/api/v1/assets/transformations/{name}";
+    readonly scope: "assets:process";
+}, {
+    readonly id: "createLifecycleRule";
+    readonly method: "POST";
+    readonly path: "/api/v1/assets/lifecycle-rules";
+    readonly scope: "assets:admin";
+}, {
+    readonly id: "listLifecycleRules";
+    readonly method: "GET";
+    readonly path: "/api/v1/assets/lifecycle-rules";
+    readonly scope: "assets:read";
+}, {
+    readonly id: "deleteLifecycleRule";
+    readonly method: "DELETE";
+    readonly path: "/api/v1/assets/lifecycle-rules/{ruleID}";
+    readonly scope: "assets:admin";
+}, {
+    readonly id: "createDomain";
+    readonly method: "POST";
+    readonly path: "/api/v1/assets/domains";
+    readonly scope: "assets:admin";
+}, {
+    readonly id: "listDomains";
+    readonly method: "GET";
+    readonly path: "/api/v1/assets/domains";
+    readonly scope: "assets:read";
+}, {
+    readonly id: "verifyDomain";
+    readonly method: "POST";
+    readonly path: "/api/v1/assets/domains/{domainID}/verify";
+    readonly scope: "assets:admin";
+}, {
+    readonly id: "deleteDomain";
+    readonly method: "DELETE";
+    readonly path: "/api/v1/assets/domains/{domainID}";
+    readonly scope: "assets:admin";
+}, {
+    readonly id: "getAnalytics";
+    readonly method: "GET";
+    readonly path: "/api/v1/assets/analytics";
+    readonly scope: "assets:read";
+}, {
+    readonly id: "getUsageSummary";
+    readonly method: "GET";
+    readonly path: "/api/v1/assets/summary";
+    readonly scope: "assets:read";
+}, {
+    readonly id: "listEvents";
+    readonly method: "GET";
+    readonly path: "/api/v1/assets/events";
+    readonly scope: "assets:read";
+}, {
+    readonly id: "createWebhook";
+    readonly method: "POST";
+    readonly path: "/api/v1/assets/webhooks";
+    readonly scope: "assets:admin";
+}, {
+    readonly id: "listWebhooks";
+    readonly method: "GET";
+    readonly path: "/api/v1/assets/webhooks";
+    readonly scope: "assets:read";
+}, {
+    readonly id: "deleteWebhook";
+    readonly method: "DELETE";
+    readonly path: "/api/v1/assets/webhooks/{webhookID}";
+    readonly scope: "assets:admin";
+}, {
+    readonly id: "listWebhookDeliveries";
+    readonly method: "GET";
+    readonly path: "/api/v1/assets/webhooks/{webhookID}/deliveries";
+    readonly scope: "assets:read";
+}, {
+    readonly id: "retryWebhookDelivery";
+    readonly method: "POST";
+    readonly path: "/api/v1/assets/webhook-deliveries/{deliveryID}/retry";
+    readonly scope: "assets:admin";
+}, {
+    readonly id: "bulkAssets";
+    readonly method: "POST";
+    readonly path: "/api/v1/assets/bulk";
+    readonly scope: "assets:write";
+}, {
+    readonly id: "listCollections";
+    readonly method: "GET";
+    readonly path: "/api/v1/assets/collections";
+    readonly scope: "assets:read";
+}, {
+    readonly id: "createCollection";
+    readonly method: "POST";
+    readonly path: "/api/v1/assets/collections";
+    readonly scope: "assets:write";
+}, {
+    readonly id: "updateCollection";
+    readonly method: "PUT";
+    readonly path: "/api/v1/assets/collections/{collectionID}";
+    readonly scope: "assets:write";
+}, {
+    readonly id: "deleteCollection";
+    readonly method: "DELETE";
+    readonly path: "/api/v1/assets/collections/{collectionID}";
+    readonly scope: "assets:write";
+}, {
+    readonly id: "listSavedSearches";
+    readonly method: "GET";
+    readonly path: "/api/v1/assets/saved-searches";
+    readonly scope: "assets:read";
+}, {
+    readonly id: "createSavedSearch";
+    readonly method: "POST";
+    readonly path: "/api/v1/assets/saved-searches";
+    readonly scope: "assets:write";
+}, {
+    readonly id: "updateSavedSearch";
+    readonly method: "PUT";
+    readonly path: "/api/v1/assets/saved-searches/{searchID}";
+    readonly scope: "assets:write";
+}, {
+    readonly id: "deleteSavedSearch";
+    readonly method: "DELETE";
+    readonly path: "/api/v1/assets/saved-searches/{searchID}";
+    readonly scope: "assets:write";
+}, {
+    readonly id: "getAIConfig";
+    readonly method: "GET";
+    readonly path: "/api/v1/assets/ai/config";
+    readonly scope: "assets:read";
+}, {
+    readonly id: "updateAIConfig";
+    readonly method: "PUT";
+    readonly path: "/api/v1/assets/ai/config";
+    readonly scope: "assets:admin";
+}, {
+    readonly id: "getJob";
+    readonly method: "GET";
+    readonly path: "/api/v1/assets/jobs/{jobID}";
+    readonly scope: "assets:read";
+}, {
+    readonly id: "cancelJob";
+    readonly method: "POST";
+    readonly path: "/api/v1/assets/jobs/{jobID}/cancel";
+    readonly scope: "assets:process";
+}, {
+    readonly id: "listAssets";
+    readonly method: "GET";
+    readonly path: "/api/v1/assets";
+    readonly scope: "assets:read";
+}, {
+    readonly id: "getAsset";
+    readonly method: "GET";
+    readonly path: "/api/v1/assets/{assetID}";
+    readonly scope: "assets:read";
+}, {
+    readonly id: "patchAsset";
+    readonly method: "PATCH";
+    readonly path: "/api/v1/assets/{assetID}";
+    readonly scope: "assets:write";
+}, {
+    readonly id: "getAssetAI";
+    readonly method: "GET";
+    readonly path: "/api/v1/assets/{assetID}/ai";
+    readonly scope: "assets:read";
+}, {
+    readonly id: "analyzeAsset";
+    readonly method: "POST";
+    readonly path: "/api/v1/assets/{assetID}/ai/analyze";
+    readonly scope: "assets:process";
+}, {
+    readonly id: "moderateAsset";
+    readonly method: "POST";
+    readonly path: "/api/v1/assets/{assetID}/moderation";
+    readonly scope: "assets:process";
+}, {
+    readonly id: "getTranscript";
+    readonly method: "GET";
+    readonly path: "/api/v1/assets/{assetID}/transcript";
+    readonly scope: "assets:read";
+}, {
+    readonly id: "transcribeAsset";
+    readonly method: "POST";
+    readonly path: "/api/v1/assets/{assetID}/transcript";
+    readonly scope: "assets:process";
+}, {
+    readonly id: "smartCropAsset";
+    readonly method: "POST";
+    readonly path: "/api/v1/assets/{assetID}/smart-crop";
+    readonly scope: "assets:process";
+}, {
+    readonly id: "removeAssetBackground";
+    readonly method: "POST";
+    readonly path: "/api/v1/assets/{assetID}/background-remove";
+    readonly scope: "assets:process";
+}, {
+    readonly id: "listAssetVersions";
+    readonly method: "GET";
+    readonly path: "/api/v1/assets/{assetID}/versions";
+    readonly scope: "assets:read";
+}, {
+    readonly id: "createAssetBranch";
+    readonly method: "POST";
+    readonly path: "/api/v1/assets/{assetID}/branches";
+    readonly scope: "assets:write";
+}, {
+    readonly id: "restoreAssetVersion";
+    readonly method: "POST";
+    readonly path: "/api/v1/assets/{assetID}/versions/{versionID}/restore";
+    readonly scope: "assets:write";
+}, {
+    readonly id: "promoteAssetBranch";
+    readonly method: "POST";
+    readonly path: "/api/v1/assets/{assetID}/branches/{branch}/promote";
+    readonly scope: "assets:write";
+}, {
+    readonly id: "deleteAsset";
+    readonly method: "DELETE";
+    readonly path: "/api/v1/assets/{assetID}";
+    readonly scope: "assets:admin";
+}, {
+    readonly id: "replaceAsset";
+    readonly method: "PUT";
+    readonly path: "/api/v1/assets/{assetID}/replace";
+    readonly scope: "assets:write";
+}, {
+    readonly id: "createSignedAssetUrl";
+    readonly method: "POST";
+    readonly path: "/api/v1/assets/{assetID}/signed-url";
+    readonly scope: "assets:read";
+}, {
+    readonly id: "createSignedTransformUrl";
+    readonly method: "POST";
+    readonly path: "/api/v1/assets/{assetID}/transform-url";
+    readonly scope: "assets:process";
+}, {
+    readonly id: "setAssetTags";
+    readonly method: "PUT";
+    readonly path: "/api/v1/assets/{assetID}/tags";
+    readonly scope: "assets:write";
+}, {
+    readonly id: "patchAssetMetadata";
+    readonly method: "PATCH";
+    readonly path: "/api/v1/assets/{assetID}/metadata";
+    readonly scope: "assets:write";
+}, {
+    readonly id: "purgeAsset";
+    readonly method: "POST";
+    readonly path: "/api/v1/assets/{assetID}/purge";
+    readonly scope: "assets:admin";
+}];

package/dist/generated/assets-contract.js

@@ -0,0 +1,66 @@
+export const assetContractOperations = [
+    { id: 'uploadAsset', method: 'POST', path: '/api/v1/assets/upload', scope: 'assets:write' },
+    { id: 'createUploadSession', method: 'POST', path: '/api/v1/assets/upload-sessions', scope: 'assets:write' },
+    { id: 'getUploadSession', method: 'GET', path: '/api/v1/assets/upload-sessions/{sessionID}', scope: 'assets:read' },
+    { id: 'completeUploadSession', method: 'POST', path: '/api/v1/assets/upload-sessions/{sessionID}/complete', scope: 'assets:write' },
+    { id: 'cancelUploadSession', method: 'DELETE', path: '/api/v1/assets/upload-sessions/{sessionID}', scope: 'assets:write' },
+    { id: 'createSignedUploadUrl', method: 'POST', path: '/api/v1/assets/upload-url', scope: 'assets:write' },
+    { id: 'createBucket', method: 'POST', path: '/api/v1/assets/buckets', scope: 'assets:admin' },
+    { id: 'listBuckets', method: 'GET', path: '/api/v1/assets/buckets', scope: 'assets:read' },
+    { id: 'updateBucket', method: 'PUT', path: '/api/v1/assets/buckets/{bucketID}', scope: 'assets:admin' },
+    { id: 'deleteBucket', method: 'DELETE', path: '/api/v1/assets/buckets/{bucketID}', scope: 'assets:admin' },
+    { id: 'getContentPolicy', method: 'GET', path: '/api/v1/assets/policy', scope: 'assets:read' },
+    { id: 'updateContentPolicy', method: 'PUT', path: '/api/v1/assets/policy', scope: 'assets:admin' },
+    { id: 'upsertTransformation', method: 'POST', path: '/api/v1/assets/transformations', scope: 'assets:process' },
+    { id: 'listTransformations', method: 'GET', path: '/api/v1/assets/transformations', scope: 'assets:read' },
+    { id: 'deleteTransformation', method: 'DELETE', path: '/api/v1/assets/transformations/{name}', scope: 'assets:process' },
+    { id: 'createLifecycleRule', method: 'POST', path: '/api/v1/assets/lifecycle-rules', scope: 'assets:admin' },
+    { id: 'listLifecycleRules', method: 'GET', path: '/api/v1/assets/lifecycle-rules', scope: 'assets:read' },
+    { id: 'deleteLifecycleRule', method: 'DELETE', path: '/api/v1/assets/lifecycle-rules/{ruleID}', scope: 'assets:admin' },
+    { id: 'createDomain', method: 'POST', path: '/api/v1/assets/domains', scope: 'assets:admin' },
+    { id: 'listDomains', method: 'GET', path: '/api/v1/assets/domains', scope: 'assets:read' },
+    { id: 'verifyDomain', method: 'POST', path: '/api/v1/assets/domains/{domainID}/verify', scope: 'assets:admin' },
+    { id: 'deleteDomain', method: 'DELETE', path: '/api/v1/assets/domains/{domainID}', scope: 'assets:admin' },
+    { id: 'getAnalytics', method: 'GET', path: '/api/v1/assets/analytics', scope: 'assets:read' },
+    { id: 'getUsageSummary', method: 'GET', path: '/api/v1/assets/summary', scope: 'assets:read' },
+    { id: 'listEvents', method: 'GET', path: '/api/v1/assets/events', scope: 'assets:read' },
+    { id: 'createWebhook', method: 'POST', path: '/api/v1/assets/webhooks', scope: 'assets:admin' },
+    { id: 'listWebhooks', method: 'GET', path: '/api/v1/assets/webhooks', scope: 'assets:read' },
+    { id: 'deleteWebhook', method: 'DELETE', path: '/api/v1/assets/webhooks/{webhookID}', scope: 'assets:admin' },
+    { id: 'listWebhookDeliveries', method: 'GET', path: '/api/v1/assets/webhooks/{webhookID}/deliveries', scope: 'assets:read' },
+    { id: 'retryWebhookDelivery', method: 'POST', path: '/api/v1/assets/webhook-deliveries/{deliveryID}/retry', scope: 'assets:admin' },
+    { id: 'bulkAssets', method: 'POST', path: '/api/v1/assets/bulk', scope: 'assets:write' },
+    { id: 'listCollections', method: 'GET', path: '/api/v1/assets/collections', scope: 'assets:read' },
+    { id: 'createCollection', method: 'POST', path: '/api/v1/assets/collections', scope: 'assets:write' },
+    { id: 'updateCollection', method: 'PUT', path: '/api/v1/assets/collections/{collectionID}', scope: 'assets:write' },
+    { id: 'deleteCollection', method: 'DELETE', path: '/api/v1/assets/collections/{collectionID}', scope: 'assets:write' },
+    { id: 'listSavedSearches', method: 'GET', path: '/api/v1/assets/saved-searches', scope: 'assets:read' },
+    { id: 'createSavedSearch', method: 'POST', path: '/api/v1/assets/saved-searches', scope: 'assets:write' },
+    { id: 'updateSavedSearch', method: 'PUT', path: '/api/v1/assets/saved-searches/{searchID}', scope: 'assets:write' },
+    { id: 'deleteSavedSearch', method: 'DELETE', path: '/api/v1/assets/saved-searches/{searchID}', scope: 'assets:write' },
+    { id: 'getAIConfig', method: 'GET', path: '/api/v1/assets/ai/config', scope: 'assets:read' },
+    { id: 'updateAIConfig', method: 'PUT', path: '/api/v1/assets/ai/config', scope: 'assets:admin' },
+    { id: 'getJob', method: 'GET', path: '/api/v1/assets/jobs/{jobID}', scope: 'assets:read' },
+    { id: 'cancelJob', method: 'POST', path: '/api/v1/assets/jobs/{jobID}/cancel', scope: 'assets:process' },
+    { id: 'listAssets', method: 'GET', path: '/api/v1/assets', scope: 'assets:read' },
+    { id: 'getAsset', method: 'GET', path: '/api/v1/assets/{assetID}', scope: 'assets:read' },
+    { id: 'patchAsset', method: 'PATCH', path: '/api/v1/assets/{assetID}', scope: 'assets:write' },
+    { id: 'getAssetAI', method: 'GET', path: '/api/v1/assets/{assetID}/ai', scope: 'assets:read' },
+    { id: 'analyzeAsset', method: 'POST', path: '/api/v1/assets/{assetID}/ai/analyze', scope: 'assets:process' },
+    { id: 'moderateAsset', method: 'POST', path: '/api/v1/assets/{assetID}/moderation', scope: 'assets:process' },
+    { id: 'getTranscript', method: 'GET', path: '/api/v1/assets/{assetID}/transcript', scope: 'assets:read' },
+    { id: 'transcribeAsset', method: 'POST', path: '/api/v1/assets/{assetID}/transcript', scope: 'assets:process' },
+    { id: 'smartCropAsset', method: 'POST', path: '/api/v1/assets/{assetID}/smart-crop', scope: 'assets:process' },
+    { id: 'removeAssetBackground', method: 'POST', path: '/api/v1/assets/{assetID}/background-remove', scope: 'assets:process' },
+    { id: 'listAssetVersions', method: 'GET', path: '/api/v1/assets/{assetID}/versions', scope: 'assets:read' },
+    { id: 'createAssetBranch', method: 'POST', path: '/api/v1/assets/{assetID}/branches', scope: 'assets:write' },
+    { id: 'restoreAssetVersion', method: 'POST', path: '/api/v1/assets/{assetID}/versions/{versionID}/restore', scope: 'assets:write' },
+    { id: 'promoteAssetBranch', method: 'POST', path: '/api/v1/assets/{assetID}/branches/{branch}/promote', scope: 'assets:write' },
+    { id: 'deleteAsset', method: 'DELETE', path: '/api/v1/assets/{assetID}', scope: 'assets:admin' },
+    { id: 'replaceAsset', method: 'PUT', path: '/api/v1/assets/{assetID}/replace', scope: 'assets:write' },
+    { id: 'createSignedAssetUrl', method: 'POST', path: '/api/v1/assets/{assetID}/signed-url', scope: 'assets:read' },
+    { id: 'createSignedTransformUrl', method: 'POST', path: '/api/v1/assets/{assetID}/transform-url', scope: 'assets:process' },
+    { id: 'setAssetTags', method: 'PUT', path: '/api/v1/assets/{assetID}/tags', scope: 'assets:write' },
+    { id: 'patchAssetMetadata', method: 'PATCH', path: '/api/v1/assets/{assetID}/metadata', scope: 'assets:write' },
+    { id: 'purgeAsset', method: 'POST', path: '/api/v1/assets/{assetID}/purge', scope: 'assets:admin' },
+];

package/dist/index.d.ts

@@ -1,5 +1,9 @@
 export { StackShift, StackShiftAPIError } from './client.js';
 export { AssetsClient, assetTransformOptions, assetTransformPresets, assetTransformSpec, getAssetTransformPreset } from './assets.js';
+export { createResponsiveImage, namedResponsiveSource, uploadBrowserFile } from './assets-framework.js';
+export type { ArtDirectionSource, ResponsiveImageDescriptor, ResponsiveImageOptions } from './assets-framework.js';
+export { assetContractOperations } from './generated/assets-contract.js';
+export type { AssetAPIScope, AssetContractOperation, AssetOperationId } from './generated/assets-contract.js';
 export { MailBouncesClient, MailClient, MailDomainsClient, MailEventsClient, MailLimitsClient, MailMessagesClient, MailScheduledClient, MailBatchClient, MailInboundClient, MailAnalyticsClient, MailOtpChallengesClient, MailOtpClient, MailReputationClient, MailReputationEventsClient, MailSuppressionsClient, MailTemplatesClient, MailWebhooksClient, } from './mail.js';
 export { ProjectsClient } from './projects.js';
 export type { Asset, AssetAIAnnotation, AssetAIInfo, AssetCollection, AssetListOptions, AssetListResult, AssetModerationResult, AssetSavedSearch, AssetSignedUploadUrl, AssetSignedUploadUrlOptions, AssetSignedUrl, AssetSignedUrlOptions, AssetTranscript, AssetTransformOptions, AssetTransformPreset, AssetTransformPresetCategory, AssetUploadOptions, AssetVisibility, AssetVersion, JsonValue, MailAddress, MailAddressInput, MailDnsRecord, MailDomain, MailDomainListResult, MailDomainStatus, MailIdempotencyStatus, MailLog, MailMessage, MailMessageListOptions, MailMessageListResult, MailMessageSummary, MailRecordStatus, MailSendAttempt, MailSendInput, MailSendResponse, MailStatus, Project, ProjectListOptions, StackShiftOptions, } from './types.js';

package/dist/index.js

@@ -1,4 +1,6 @@
 export { StackShift, StackShiftAPIError } from './client.js';
 export { AssetsClient, assetTransformOptions, assetTransformPresets, assetTransformSpec, getAssetTransformPreset } from './assets.js';
+export { createResponsiveImage, namedResponsiveSource, uploadBrowserFile } from './assets-framework.js';
+export { assetContractOperations } from './generated/assets-contract.js';
 export { MailBouncesClient, MailClient, MailDomainsClient, MailEventsClient, MailLimitsClient, MailMessagesClient, MailScheduledClient, MailBatchClient, MailInboundClient, MailAnalyticsClient, MailOtpChallengesClient, MailOtpClient, MailReputationClient, MailReputationEventsClient, MailSuppressionsClient, MailTemplatesClient, MailWebhooksClient, } from './mail.js';
 export { ProjectsClient } from './projects.js';

package/dist/types.d.ts

@@ -149,12 +149,13 @@ export interface Asset {
     size: number;
     checksum_sha256: string;
     visibility: AssetVisibility;
-    status: 'uploading' | 'available' | 'deleted' | 'failed';
+    status: 'processing' | 'ready' | 'quarantined' | 'failed' | 'deleting' | 'deleted';
     replication_status: 'pending' | 'replicated' | 'degraded' | 'failed';
     scan_status?: 'pending' | 'clean' | 'infected' | 'failed' | 'skipped';
     scan_result?: string;
     quarantine_status?: 'none' | 'infected' | 'policy';
     video_status?: 'none' | 'pending' | 'processing' | 'ready' | 'failed' | 'skipped';
+    video_progress_percent?: number;
     ai_status?: 'pending' | 'processing' | 'ready' | 'failed' | 'skipped';
     moderation_status?: 'pending' | 'processing' | 'clean' | 'flagged' | 'quarantined' | 'failed';
     moderation_reason?: string;
@@ -166,6 +167,8 @@ export interface Asset {
     video?: AssetVideoInfo;
     ai?: AssetAIInfo;
     url?: string;
+    generation: number;
+    revision: number;
     created_at: string;
     updated_at: string;
 }
@@ -257,6 +260,13 @@ export interface AssetListOptions {
     type?: string;
     folder?: string;
     checksum?: string;
+    status?: Asset['status'];
+    scanStatus?: string;
+    replicationStatus?: string;
+    moderationStatus?: string;
+    quarantineStatus?: string;
+    sort?: 'created_at' | 'updated_at' | 'size' | 'key' | 'original_name' | 'mime_type';
+    direction?: 'asc' | 'desc';
     limit?: number;
     cursor?: string;
 }
@@ -282,6 +292,55 @@ export interface AssetSignedUploadUrlOptions extends AssetUploadOptions {
     partSize?: number;
     expiresIn?: string;
     maxBytes?: number;
+    idempotencyKey?: string;
+    /** Resume an existing multipart upload instead of creating another session. */
+    uploadSessionId?: string;
+    /** Multipart worker count. Defaults to 4 and is capped at 8. */
+    concurrency?: number;
+    /** Attempts per multipart request. Defaults to 4 and is capped at 8. */
+    retryAttempts?: number;
+}
+export interface AssetBucket {
+    id: string;
+    name: string;
+    default_visibility: AssetVisibility;
+    cache_control?: string;
+    versioning: boolean;
+    retention_days: number;
+    max_object_bytes?: number;
+    allowed_mime_types: string[];
+    home_region: string;
+    replication_policy: 'global-3';
+    cors_origins: string[];
+    allowed_origins: string[];
+    lifecycle_policy: Record<string, unknown>;
+    custom_domain_id?: string;
+    revision: number;
+    created_at: string;
+    updated_at: string;
+}
+export interface AssetBucketInput {
+    name?: string;
+    default_visibility?: AssetVisibility;
+    cache_control?: string;
+    versioning?: boolean;
+    retention_days?: number;
+    max_object_bytes?: number;
+    allowed_mime_types?: string[];
+    home_region?: string;
+    replication_policy?: 'global-3';
+    cors_origins?: string[];
+    allowed_origins?: string[];
+    lifecycle_policy?: Record<string, unknown>;
+    custom_domain_id?: string;
+}
+export interface AssetPatchInput {
+    bucket?: string;
+    key?: string;
+    original_name?: string;
+    cache_control?: string;
+    clear_cache_control?: boolean;
+    visibility?: AssetVisibility;
 }
 export interface AssetSignedUploadUrl {
     upload_session_id: string;
@@ -311,10 +370,24 @@ export interface AssetUploadProgressCallbacks {
         total: number;
         percent: number;
     }) => void;
+    /** Cancels in-flight browser requests and the server-side upload session. */
+    signal?: AbortSignal;
 }
 export interface AssetUsageSummary {
     total_assets: number;
     total_bytes: number;
+    period_ingress_bytes: number;
+    period_egress_bytes: number;
+    period_origin_bytes: number;
+    period_verification_bytes: number;
+    period_transform_count: number;
+    period_ai_requests: number;
+    period_logical_storage_byte_hours: number;
+    period_physical_storage_byte_hours: number;
+    period_derived_storage_byte_hours: number;
+    period_transform_compute_ms: number;
+    period_video_input_seconds: number;
+    period_ai_cost_micros: number;
     by_bucket: Record<string, number>;
     by_mime_family: Record<string, number>;
     by_visibility: Record<string, number>;
@@ -324,6 +397,97 @@ export interface AssetUsageSummary {
         total_bytes: number;
     }>;
 }
+export interface AssetJobSubmission {
+    job_id: string;
+    status: string;
+    status_url: string;
+}
+export interface AssetJob {
+    id: string;
+    job_name: string;
+    status: string;
+    progress_percent: number;
+    phase: 'queued' | 'processing' | 'waiting' | 'ready' | 'failed' | 'cancelled' | string;
+    attempt: number;
+    max_attempts: number;
+    created_at: string;
+    started_at?: string;
+    completed_at?: string;
+    error?: string;
+}
+export interface AssetAIPolicy {
+    enabled_actions: Array<'analyze' | 'transcribe' | 'smart_crop' | 'background_remove'>;
+    monthly_spend_cap_micros: number;
+    revision: number;
+}
+export interface AssetAIAccountConfig {
+    provider: string;
+    configured: boolean;
+    actions: string[];
+    policy: AssetAIPolicy;
+    monthly_spend_used_micros: number;
+}
+export interface AssetLifecycleRule {
+    id: string;
+    name: string;
+    prefix?: string;
+    action: 'delete' | 'expire_versions';
+    age_days: number;
+    enabled: boolean;
+    created_at: string;
+    updated_at: string;
+    last_run_at?: string;
+    last_error?: string;
+}
+export interface AssetCustomDomain {
+    id: string;
+    domain: string;
+    status: string;
+    verification_name: string;
+    verification_value: string;
+    last_error?: string;
+    provider_domain_id?: string;
+    certificate_id?: string;
+    created_at: string;
+    updated_at: string;
+    verified_at?: string;
+}
+export interface AssetEvent {
+    id: string;
+    asset_id?: string;
+    type: string;
+    data: Record<string, unknown>;
+    created_at: string;
+}
+export interface AssetWebhook {
+    id: string;
+    url: string;
+    event_types: string[];
+    status: 'active' | 'disabled';
+    failure_count: number;
+    last_success_at?: string;
+    last_failure_at?: string;
+    disabled_at?: string;
+    created_by: string;
+    created_at: string;
+    updated_at: string;
+}
+export interface AssetWebhookDelivery {
+    id: string;
+    webhook_id: string;
+    event_id: string;
+    event_type: string;
+    payload: Record<string, unknown>;
+    status: 'pending' | 'delivering' | 'succeeded' | 'failed';
+    attempt_count: number;
+    next_attempt_at: string;
+    status_code?: number;
+    response_snippet?: string;
+    error_message?: string;
+    created_at: string;
+    updated_at: string;
+    delivered_at?: string;
+}
 export interface AssetContentPolicy {
     allowed_mime_types: string[];
     max_image_bytes: number;
@@ -340,6 +504,8 @@ export interface AssetTransformOptions {
     crop?: AssetTransformCrop;
     format?: AssetTransformFormat;
     quality?: AssetTransformQuality;
+    gravity?: 'centre' | 'attention' | 'entropy';
+    animation?: 'first' | 'reject';
 }
 export interface AssetNamedTransformInput extends AssetTransformOptions {
     name: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackshift-cloud/sdk",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Official JavaScript and TypeScript SDK for StackShift.",
   "type": "module",
   "main": "./dist/index.js",