@vivix-labs/project-studio 0.0.0-stage → 1.0.0-beta

package/dist/shared-BUdviVVD.d.ts

@@ -0,0 +1,263 @@
+import { CallContext as CallContext$1 } from 'vivix-studio/sdk/shared';
+
+type Scope = {
+    kind: 'user' | 'project';
+    id: string;
+};
+type CallContext = CallContext$1 & {
+    scope?: Scope;
+    confirmed?: boolean;
+    originalRequestKey?: string;
+    sourceOperation?: string;
+};
+interface BindingRequest {
+    scope: Scope;
+    ownerPackage: string;
+    packageVersion: string;
+    actorId: string;
+    access: readonly string[];
+}
+interface DataWorkspace {
+    readonly storeId: string;
+    bind(request: BindingRequest): DataAPI & BusinessWorkspaceView;
+}
+type JSONValue = null | boolean | number | string | JSONValue[] | {
+    [key: string]: JSONValue;
+};
+interface RecordValue {
+    storeId: string;
+    scope: Scope;
+    objectId: string;
+    typeId: string;
+    schemaVersion: number;
+    revision: number;
+    data: any;
+    metadata: Record<string, JSONValue>;
+    createdAt: string;
+    updatedAt: string;
+    deletedAt: string | null;
+}
+interface VersionRef {
+    storeId: string;
+    objectId: string;
+    versionId: string;
+}
+interface VersionValue {
+    versionId: string;
+    objectId: string;
+    versionNumber: number;
+    schemaVersion: number;
+    parentVersionId: string | null;
+    sourceRef: VersionRef | null;
+    origin: string;
+    taskId: string | null;
+    payload: any;
+    metadata: any;
+    contentDigest: string;
+    createdAt: string;
+}
+interface FileValue {
+    fileId: string;
+    relativePath: string;
+    originalName: string;
+    mimeType: string;
+    sizeBytes: number;
+    sha256: string;
+    createdAt: string;
+    role: string;
+    ordinal: number;
+}
+type ProbeRunner = (path: string, signal?: AbortSignal, context?: {
+    directory: string;
+}) => Promise<{
+    stdout: string;
+    stderr: string;
+}>;
+interface StageOptions {
+    signal?: AbortSignal;
+    probeRunner?: ProbeRunner;
+    onPrepared?: (stagingFileId: string) => void | Promise<void>;
+}
+interface StagedFile {
+    stagingFileId: string;
+    kind: string;
+    mimeType: string;
+    sizeBytes: number;
+    sha256: string;
+    originalName: string;
+    details: Record<string, any>;
+}
+type SqlScalar = null | string | number;
+interface SqlInput {
+    sql: string;
+    params?: SqlScalar[] | Record<string, SqlScalar>;
+    timeoutMs?: number;
+    maxRows?: number;
+    limit?: number;
+    offset?: number;
+}
+type SqlRow = Record<string, JSONValue>;
+type SqlTables = Record<string, {
+    columns: string[];
+    rows: SqlRow[];
+}>;
+interface MutationInput {
+    table: string;
+    action: 'insert' | 'update' | 'delete';
+    key?: Record<string, SqlScalar>;
+    values?: Record<string, SqlScalar>;
+    expectedRevision?: number;
+}
+interface MutationResult {
+    changes: number;
+    items: SqlRow[];
+}
+interface MigrationStatus {
+    id: string;
+    sha256: string;
+    appliedSha256: string | null;
+    state: 'pending' | 'applied' | 'drifted' | 'failed' | 'blocked';
+}
+interface MigrationInput {
+    expected: Array<{
+        id: string;
+        sha256: string;
+    }>;
+}
+interface MigrationResult {
+    applied: string[];
+    backup: string;
+}
+interface MigrationAPI {
+    status(): Promise<MigrationStatus[]>;
+    apply(input: MigrationInput, call: CallContext): Promise<MigrationResult>;
+}
+interface Query {
+    typeId: string;
+    search?: string;
+    kind?: string;
+    tag?: string;
+    targetAssetId?: string;
+    taskId?: string;
+    outputIndex?: number;
+    metadataEquals?: Record<string, JSONValue>;
+    metadataContains?: Record<string, JSONValue>;
+    sort?: 'name' | 'createdAt' | 'updatedAt';
+    direction?: 'asc' | 'desc';
+    limit?: number;
+    offset?: number;
+    includeDeleted?: boolean;
+}
+interface TypeDefinition {
+    typeId: string;
+    schemaVersion: number;
+    scopeKinds: ('user' | 'project')[];
+    validate(data: any): any;
+    validateUpdate?(before: any, after: any): void;
+}
+interface Transaction {
+    get(id: string, includeDeleted?: boolean): RecordValue;
+    create(typeId: string, data: any, metadata?: any, id?: string): RecordValue;
+    update(id: string, expectedRevision: number, data: any, metadata?: any, deletedAt?: string | null): RecordValue;
+    commitVersion(id: string, expectedRevision: number, value: {
+        parentVersionId?: string | null;
+        sourceRef?: VersionRef | null;
+        origin: string;
+        taskId?: string | null;
+        payload: any;
+        metadata?: any;
+        files?: FileValue[];
+        versionId?: string;
+    }): VersionValue;
+    /** Clear only mutable record-level references owned by this binding; version references remain immutable. */
+    removeRelations(sourceObjectId: string, kind: 'reference'): void;
+    relation(sourceObjectId: string, sourceVersionId: string | null, target: VersionRef, kind: 'source' | 'input' | 'reference'): void;
+}
+interface DataAPI {
+    readonly storeId: string;
+    readonly scope: Scope;
+    get(id: string, includeDeleted?: boolean): RecordValue;
+    list(query: Query): {
+        items: RecordValue[];
+        nextOffset: number | null;
+    };
+    query(input: SqlInput): Promise<SqlRow[]>;
+    mutate(input: MutationInput, call: CallContext): Promise<MutationResult>;
+    versions(id: string): VersionValue[];
+    version(ref: VersionRef): VersionValue;
+    files(ref: VersionRef): FileValue[];
+    receipt(name: string, input: unknown, call: CallContext): {
+        result: any;
+    } | null;
+    reserve(name: string, input: unknown, call: CallContext): {
+        result: any;
+    } | null;
+    operation<T>(name: string, input: unknown, call: CallContext, action: (tx: Transaction) => T): T;
+    patchMetadata(id: string, revision: number, set: Record<string, JSONValue>, remove: string[], call: CallContext): RecordValue;
+    metadataKeys(typeId: string, limit?: number): {
+        key: string;
+        types: string[];
+        observedCount: number;
+    }[];
+    stage(source: AsyncIterable<Uint8Array>, originalName: string, actorId: string, options?: StageOptions): Promise<StagedFile>;
+    stageText(text: string, actorId: string): Promise<StagedFile>;
+    publish(stagingIds: string[], objectId: string, versionId: string, operationId: string, actorId: string, fileRoles?: string[]): Promise<{
+        files: FileValue[];
+        details: any;
+        kind: string;
+    }>;
+    finishFiles(operationId: string): Promise<void>;
+    discardStaging(stagingFileId: string): Promise<void>;
+    discardPublication(operationId: string): Promise<void>;
+    location(ref: VersionRef, fileId?: string): Promise<{
+        source: VersionRef;
+        absolutePath: string;
+        fileId: string;
+        mimeType: string;
+        availability: 'ready';
+        previewUrl: string | null;
+    }>;
+    availability(ref: VersionRef): Promise<'ready' | 'missing' | 'corrupt'>;
+    openFile(ref: VersionRef, fileId: string, signal: AbortSignal): Promise<ReadableStream<Uint8Array>>;
+    usages(ref: {
+        objectId: string;
+        versionId?: string;
+        limit?: number;
+        offset?: number;
+    }): any[];
+    usageCount(objectId: string): number;
+    documents(action: 'create' | 'update' | 'delete', input: any, call: CallContext): RecordValue;
+    impact(id: string): any;
+    purge(id: string, revision: number, call: CallContext): any;
+}
+interface BusinessWorkspaceView {
+    queryWorkspace(input: SqlInput): Promise<SqlRow[]>;
+    queryProjection(input: SqlInput, tables: SqlTables): Promise<SqlRow[]>;
+    readonly migrations: MigrationAPI;
+    register(definition: TypeDefinition): void;
+    ensureProject(id: string, data: any, call: CallContext): RecordValue;
+    projectRecords(query?: {
+        search?: string;
+        status?: string;
+        sort?: string;
+        direction?: string;
+        limit?: number;
+        offset?: number;
+    }): RecordValue[];
+    createProject(id: string, data: any, call: CallContext): RecordValue;
+    projects(): DataAPI;
+    project(id: string): DataAPI;
+    tasks(query?: {
+        limit?: number;
+        offset?: number;
+        unfinished?: boolean;
+        needsCostSync?: boolean;
+        afterId?: string;
+    }): RecordValue[];
+    source(ref: VersionRef): DataAPI;
+    backup(destination: string): Promise<any>;
+    restore(source: string): Promise<any>;
+    recoverFiles(): Promise<any>;
+}
+
+export type { CallContext as C, DataAPI as D, FileValue as F, JSONValue as J, RecordValue as R, Scope as S, VersionRef as V, DataWorkspace as a, SqlInput as b, SqlRow as c, VersionValue as d };