@stackshift-cloud/sdk 1.0.0 → 1.2.0

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-platform-types.d.ts

@@ -0,0 +1,218 @@
+import type { Asset, AssetBucket, JsonValue } from './types.js';
+export type AssetConnectionProvider = 'aws_s3' | 'r2' | 'wasabi' | 'minio' | 's3' | 'stackshift_s2' | 'cloudinary';
+export type AssetConnectionStatus = 'unverified' | 'verified' | 'failed' | 'revoked';
+export type AssetStorageMode = 'managed' | 'byob' | 'stackshift_s2';
+export type AssetMigrationStatus = 'queued' | 'running' | 'completed' | 'failed' | 'canceled';
+export type AssetMigrationItemStatus = 'queued' | 'running' | 'imported' | 'skipped' | 'failed' | 'canceled';
+export interface AssetConnection {
+    id: string;
+    provider: AssetConnectionProvider;
+    name: string;
+    configuration: Record<string, JsonValue>;
+    external_id: string;
+    s2_bucket_id?: string;
+    status: AssetConnectionStatus;
+    last_verified_at?: string;
+    verification_error?: string;
+    created_at: string;
+    updated_at: string;
+}
+export interface AssetS3ConnectionConfiguration {
+    bucket: string;
+    region?: string;
+    endpoint?: string;
+    prefix?: string;
+    role_arn?: string;
+    auth_type: 'assume_role' | 'static';
+    path_style?: boolean;
+}
+export interface AssetS3StaticCredentials {
+    access_key_id: string;
+    secret_access_key: string;
+    session_token?: string;
+}
+export interface AssetCloudinaryConfiguration {
+    cloud_name: string;
+    api_key: string;
+}
+export interface AssetCloudinaryCredentials {
+    api_secret: string;
+}
+interface AssetConnectionInputBase {
+    name: string;
+}
+export type AssetConnectionInput = AssetConnectionInputBase & ({
+    provider: 'aws_s3';
+    configuration: AssetS3ConnectionConfiguration;
+    credentials?: AssetS3StaticCredentials;
+} | {
+    provider: 'r2' | 'wasabi' | 'minio' | 's3';
+    configuration: AssetS3ConnectionConfiguration;
+    credentials: AssetS3StaticCredentials;
+} | {
+    provider: 'cloudinary';
+    configuration: AssetCloudinaryConfiguration;
+    credentials: AssetCloudinaryCredentials;
+} | {
+    provider: 'stackshift_s2';
+    s2_bucket_id: string;
+    configuration?: never;
+    credentials?: never;
+});
+export interface AssetStorageConfiguration {
+    storage_mode: AssetStorageMode;
+    connection_id?: string;
+    s2_bucket_id?: string;
+    object_prefix?: string;
+    derivative_prefix?: string;
+    auto_extract_text?: boolean;
+    expected_revision?: number;
+}
+export interface AssetS2Bucket {
+    id: string;
+    name: string;
+    workspace_id?: string;
+    project_id?: string;
+    region: string;
+    visibility: string;
+    versioning_enabled: boolean;
+    quota_bytes?: number;
+    object_count: number;
+    size_bytes: number;
+    created_at: string;
+    updated_at: string;
+}
+export interface AssetMigrationInput {
+    kind?: 'import' | 'relocate';
+    source_connection_id?: string;
+    destination_bucket_id: string;
+    source_prefix?: string;
+    conflict_policy?: 'skip' | 'new_version' | 'rename';
+    dry_run?: boolean;
+}
+export interface AssetMigration {
+    id: string;
+    kind: 'import' | 'relocate';
+    source_connection_id?: string;
+    destination_bucket_id: string;
+    source_prefix: string;
+    conflict_policy: 'skip' | 'new_version' | 'rename';
+    dry_run: boolean;
+    status: AssetMigrationStatus;
+    phase: 'inventory' | 'transfer' | 'complete' | string;
+    total_items: number;
+    processed_items: number;
+    imported_items: number;
+    skipped_items: number;
+    failed_items: number;
+    total_bytes: number;
+    processed_bytes: number;
+    report: Record<string, JsonValue>;
+    cancel_requested_at?: string;
+    started_at?: string;
+    completed_at?: string;
+    created_at: string;
+    updated_at: string;
+}
+export interface AssetMigrationItem {
+    id: string;
+    migration_id: string;
+    source_identity: string;
+    source_key: string;
+    destination_key: string;
+    content_type?: string;
+    size?: number;
+    checksum_sha256?: string;
+    checksum_state: 'known' | 'pending_execution' | 'verified';
+    source_metadata: Record<string, JsonValue>;
+    source_tags: string[];
+    status: AssetMigrationItemStatus;
+    attempt_count: number;
+    max_attempts: number;
+    mapped_asset_id?: string;
+    warning_code?: string;
+    error_code?: string;
+    error_message?: string;
+    created_at: string;
+    updated_at: string;
+    finished_at?: string;
+}
+export interface AssetTextBlock {
+    text: string;
+    type: string;
+    confidence: number;
+    box: [number, number, number, number];
+}
+export interface AssetTextPage {
+    number: number;
+    width: number;
+    height: number;
+    blocks: AssetTextBlock[];
+}
+export interface AssetTextExtraction {
+    id: string;
+    checksum_sha256: string;
+    provider: string;
+    engine_version: string;
+    language: string;
+    options_hash: string;
+    status: 'pending' | 'processing' | 'ready' | 'failed';
+    plain_text?: string;
+    pages: AssetTextPage[];
+    page_count: number;
+    error_code?: string;
+    error_message?: string;
+    created_at: string;
+    updated_at: string;
+    completed_at?: string;
+}
+export interface AssetUploadCapabilityInput {
+    bucket: string;
+    key_prefix?: string;
+    fixed_key?: string;
+    allowed_mime_types?: string[];
+    allowed_origins: string[];
+    max_bytes: number;
+    allow_remote_url?: boolean;
+    expires_in: string;
+}
+export interface AssetUploadCapability {
+    id: string;
+    bucket: string;
+    key_prefix: string;
+    fixed_key?: string;
+    allowed_mime_types: string[];
+    allowed_origins: string[];
+    max_bytes: number;
+    allow_remote_url: boolean;
+    session_id?: string;
+    expires_at: string;
+    created_at: string;
+}
+export interface CreatedAssetUploadCapability {
+    capability: AssetUploadCapability;
+    token: string;
+}
+export interface AssetMigrationListResult {
+    migrations: AssetMigration[];
+}
+export interface AssetConnectionListResult {
+    connections: AssetConnection[];
+}
+export interface AssetS2BucketListResult {
+    buckets: AssetS2Bucket[];
+}
+export interface AssetRelocationInput {
+    dry_run?: boolean;
+}
+export interface AssetTextExtractionInput {
+    language?: string;
+    options?: Record<string, JsonValue>;
+}
+export type AssetMigrationReport = {
+    migration: AssetMigration;
+    items: AssetMigrationItem[];
+} | Record<string, JsonValue>;
+export type AssetCapabilityUploadResult = Asset;
+export type AssetStorageBucket = AssetBucket;
+export {};

package/dist/assets-platform-types.js

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

package/dist/assets-platform.d.ts

@@ -0,0 +1,55 @@
+import type { StackShift } from './client.js';
+import type { AssetBucket } from './types.js';
+import type { AssetConnection, AssetConnectionInput, AssetConnectionListResult, AssetMigration, AssetMigrationInput, AssetMigrationListResult, AssetMigrationReport, AssetRelocationInput, AssetS2Bucket, AssetS2BucketListResult, AssetStorageConfiguration, AssetTextExtraction, AssetTextExtractionInput, AssetUploadCapabilityInput, CreatedAssetUploadCapability } from './assets-platform-types.js';
+export declare class AssetConnectionsClient {
+    private readonly client;
+    constructor(client: StackShift);
+    list(): Promise<AssetConnectionListResult>;
+    get(connectionId: string): Promise<AssetConnection>;
+    create(input: AssetConnectionInput): Promise<AssetConnection>;
+    update(connectionId: string, input: Partial<AssetConnectionInput>): Promise<AssetConnection>;
+    verify(connectionId: string): Promise<AssetConnection>;
+    delete(connectionId: string): Promise<{
+        deleted: boolean;
+    }>;
+}
+export declare class AssetStorageClient {
+    private readonly client;
+    constructor(client: StackShift);
+    configure(bucketId: string, revision: number, input: AssetStorageConfiguration): Promise<AssetBucket>;
+    listS2Buckets(): Promise<AssetS2BucketListResult>;
+    createS2Bucket(input: {
+        name: string;
+        region: string;
+    }): Promise<AssetS2Bucket>;
+    relocate(bucketId: string, input?: AssetRelocationInput): Promise<AssetMigration>;
+}
+export declare class AssetMigrationsClient {
+    private readonly client;
+    constructor(client: StackShift);
+    start(input: AssetMigrationInput): Promise<AssetMigration>;
+    list(options?: {
+        limit?: number;
+    }): Promise<AssetMigrationListResult>;
+    get(migrationId: string): Promise<AssetMigration>;
+    cancel(migrationId: string): Promise<{
+        canceled: boolean;
+    }>;
+    retryItem(migrationId: string, itemId: string): Promise<{
+        queued: boolean;
+    }>;
+    report(migrationId: string, format?: 'json'): Promise<AssetMigrationReport>;
+    downloadReport(migrationId: string, format?: 'json' | 'csv'): Promise<Blob>;
+}
+export declare class AssetTextClient {
+    private readonly client;
+    constructor(client: StackShift);
+    start(assetId: string, input?: AssetTextExtractionInput): Promise<AssetTextExtraction>;
+    get(assetId: string): Promise<AssetTextExtraction>;
+    retry(extractionId: string): Promise<AssetTextExtraction>;
+}
+export declare class AssetUploadCapabilitiesClient {
+    private readonly client;
+    constructor(client: StackShift);
+    create(input: AssetUploadCapabilityInput): Promise<CreatedAssetUploadCapability>;
+}