@elaraai/e3-api-server 0.0.1-alpha.2

package/dist/src/types.d.ts

@@ -0,0 +1,1310 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Licensed under BSL 1.1. See LICENSE for details.
+ */
+/**
+ * API types for e3-api-server and e3-api-client.
+ *
+ * All types are East types for BEAST2 serialization.
+ */
+import { VariantType, StructType, ArrayType, OptionType, StringType, IntegerType, FloatType, BooleanType, NullType, type EastType, type ValueTypeOf } from '@elaraai/east';
+export declare const WorkspaceNotFoundErrorType: StructType<{
+    workspace: StringType;
+}>;
+export declare const WorkspaceNotDeployedErrorType: StructType<{
+    workspace: StringType;
+}>;
+export declare const WorkspaceExistsErrorType: StructType<{
+    workspace: StringType;
+}>;
+export declare const LockHolderType: StructType<{
+    pid: IntegerType;
+    acquiredAt: StringType;
+    bootId: OptionType<StringType>;
+    command: OptionType<StringType>;
+}>;
+export declare const WorkspaceLockedErrorType: StructType<{
+    workspace: StringType;
+    holder: VariantType<{
+        unknown: NullType;
+        known: StructType<{
+            pid: IntegerType;
+            acquiredAt: StringType;
+            bootId: OptionType<StringType>;
+            command: OptionType<StringType>;
+        }>;
+    }>;
+}>;
+export declare const PackageNotFoundErrorType: StructType<{
+    packageName: StringType;
+    version: OptionType<StringType>;
+}>;
+export declare const PackageExistsErrorType: StructType<{
+    packageName: StringType;
+    version: StringType;
+}>;
+export declare const PackageInvalidErrorType: StructType<{
+    reason: StringType;
+}>;
+export declare const DatasetNotFoundErrorType: StructType<{
+    workspace: StringType;
+    path: StringType;
+}>;
+export declare const TaskNotFoundErrorType: StructType<{
+    task: StringType;
+}>;
+export declare const ObjectNotFoundErrorType: StructType<{
+    hash: StringType;
+}>;
+export declare const DataflowErrorType: StructType<{
+    message: StringType;
+}>;
+export declare const PermissionDeniedErrorType: StructType<{
+    path: StringType;
+}>;
+export declare const InternalErrorType: StructType<{
+    message: StringType;
+}>;
+export declare const ErrorType: VariantType<{
+    workspace_not_found: StructType<{
+        workspace: StringType;
+    }>;
+    workspace_not_deployed: StructType<{
+        workspace: StringType;
+    }>;
+    workspace_exists: StructType<{
+        workspace: StringType;
+    }>;
+    workspace_locked: StructType<{
+        workspace: StringType;
+        holder: VariantType<{
+            unknown: NullType;
+            known: StructType<{
+                pid: IntegerType;
+                acquiredAt: StringType;
+                bootId: OptionType<StringType>;
+                command: OptionType<StringType>;
+            }>;
+        }>;
+    }>;
+    package_not_found: StructType<{
+        packageName: StringType;
+        version: OptionType<StringType>;
+    }>;
+    package_exists: StructType<{
+        packageName: StringType;
+        version: StringType;
+    }>;
+    package_invalid: StructType<{
+        reason: StringType;
+    }>;
+    dataset_not_found: StructType<{
+        workspace: StringType;
+        path: StringType;
+    }>;
+    task_not_found: StructType<{
+        task: StringType;
+    }>;
+    object_not_found: StructType<{
+        hash: StringType;
+    }>;
+    dataflow_error: StructType<{
+        message: StringType;
+    }>;
+    dataflow_aborted: NullType;
+    permission_denied: StructType<{
+        path: StringType;
+    }>;
+    internal: StructType<{
+        message: StringType;
+    }>;
+}>;
+export declare const ResponseType: <T extends EastType>(successType: T) => VariantType<{
+    success: T;
+    error: VariantType<{
+        workspace_not_found: StructType<{
+            workspace: StringType;
+        }>;
+        workspace_not_deployed: StructType<{
+            workspace: StringType;
+        }>;
+        workspace_exists: StructType<{
+            workspace: StringType;
+        }>;
+        workspace_locked: StructType<{
+            workspace: StringType;
+            holder: VariantType<{
+                unknown: NullType;
+                known: StructType<{
+                    pid: IntegerType;
+                    acquiredAt: StringType;
+                    bootId: OptionType<StringType>;
+                    command: OptionType<StringType>;
+                }>;
+            }>;
+        }>;
+        package_not_found: StructType<{
+            packageName: StringType;
+            version: OptionType<StringType>;
+        }>;
+        package_exists: StructType<{
+            packageName: StringType;
+            version: StringType;
+        }>;
+        package_invalid: StructType<{
+            reason: StringType;
+        }>;
+        dataset_not_found: StructType<{
+            workspace: StringType;
+            path: StringType;
+        }>;
+        task_not_found: StructType<{
+            task: StringType;
+        }>;
+        object_not_found: StructType<{
+            hash: StringType;
+        }>;
+        dataflow_error: StructType<{
+            message: StringType;
+        }>;
+        dataflow_aborted: NullType;
+        permission_denied: StructType<{
+            path: StringType;
+        }>;
+        internal: StructType<{
+            message: StringType;
+        }>;
+    }>;
+}>;
+/**
+ * Repository status information.
+ *
+ * @property path - Absolute path to the .e3 repository directory
+ * @property objectCount - Number of content-addressed objects stored
+ * @property packageCount - Number of imported packages
+ * @property workspaceCount - Number of workspaces
+ */
+export declare const RepositoryStatusType: StructType<{
+    path: StringType;
+    objectCount: IntegerType;
+    packageCount: IntegerType;
+    workspaceCount: IntegerType;
+}>;
+/**
+ * Garbage collection request options.
+ *
+ * @property dryRun - If true, report what would be deleted without deleting
+ * @property minAge - Minimum age in milliseconds for objects to be considered for deletion
+ */
+export declare const GcRequestType: StructType<{
+    dryRun: BooleanType;
+    minAge: OptionType<IntegerType>;
+}>;
+/**
+ * Garbage collection result.
+ *
+ * @property deletedObjects - Number of unreferenced objects deleted
+ * @property deletedPartials - Number of incomplete uploads deleted
+ * @property retainedObjects - Number of objects still referenced
+ * @property skippedYoung - Number of objects skipped due to minAge
+ * @property bytesFreed - Total bytes freed by deletion
+ */
+export declare const GcResultType: StructType<{
+    deletedObjects: IntegerType;
+    deletedPartials: IntegerType;
+    retainedObjects: IntegerType;
+    skippedYoung: IntegerType;
+    bytesFreed: IntegerType;
+}>;
+/**
+ * Package list item (summary info).
+ *
+ * @property name - Package name
+ * @property version - Semantic version string
+ */
+export declare const PackageListItemType: StructType<{
+    name: StringType;
+    version: StringType;
+}>;
+/**
+ * Result of importing a package.
+ *
+ * @property name - Imported package name
+ * @property version - Imported package version
+ * @property packageHash - SHA256 hash of the package content
+ * @property objectCount - Number of objects added to the repository
+ */
+export declare const PackageImportResultType: StructType<{
+    name: StringType;
+    version: StringType;
+    packageHash: StringType;
+    objectCount: IntegerType;
+}>;
+/**
+ * Basic package info.
+ *
+ * @property name - Package name
+ * @property version - Semantic version string
+ * @property hash - SHA256 content hash
+ */
+export declare const PackageInfoType: StructType<{
+    name: StringType;
+    version: StringType;
+    hash: StringType;
+}>;
+/**
+ * Detailed package information including structure.
+ *
+ * @property name - Package name
+ * @property version - Semantic version string
+ * @property hash - SHA256 content hash
+ * @property tasks - List of task names defined in the package
+ * @property dataStructure - East structure type describing the package's data schema
+ */
+export declare const PackageDetailsType: StructType<{
+    name: StringType;
+    version: StringType;
+    hash: StringType;
+    tasks: ArrayType<StringType>;
+    dataStructure: import("@elaraai/east").RecursiveType<VariantType<{
+        value: import("@elaraai/east").RecursiveType<VariantType<{
+            Never: import("@elaraai/east").NullType;
+            Null: import("@elaraai/east").NullType;
+            Boolean: import("@elaraai/east").NullType;
+            Integer: import("@elaraai/east").NullType;
+            Float: import("@elaraai/east").NullType;
+            String: import("@elaraai/east").NullType;
+            DateTime: import("@elaraai/east").NullType;
+            Blob: import("@elaraai/east").NullType;
+            Ref: import("@elaraai/east").RecursiveTypeMarker;
+            Array: import("@elaraai/east").RecursiveTypeMarker;
+            Set: import("@elaraai/east").RecursiveTypeMarker;
+            Dict: import("@elaraai/east").StructType<{
+                key: import("@elaraai/east").RecursiveTypeMarker;
+                value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            Struct: ArrayType<import("@elaraai/east").StructType<{
+                name: StringType;
+                type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            Variant: ArrayType<import("@elaraai/east").StructType<{
+                name: StringType;
+                type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            Recursive: import("@elaraai/east").IntegerType;
+            Function: import("@elaraai/east").StructType<{
+                inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            AsyncFunction: import("@elaraai/east").StructType<{
+                inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+        }>>;
+        struct: import("@elaraai/east").DictType<StringType, import("@elaraai/east").RecursiveTypeMarker>;
+    }>>;
+}>;
+/**
+ * Request to create a new workspace.
+ *
+ * @property name - Unique workspace name
+ */
+export declare const WorkspaceCreateRequestType: StructType<{
+    name: StringType;
+}>;
+/** @deprecated Use WorkspaceCreateRequestType */
+export declare const CreateWorkspaceType: StructType<{
+    name: StringType;
+}>;
+/**
+ * Workspace summary information.
+ *
+ * @property name - Workspace name
+ * @property deployed - Whether a package is deployed to this workspace
+ * @property packageName - Name of deployed package (if deployed)
+ * @property packageVersion - Version of deployed package (if deployed)
+ */
+export declare const WorkspaceInfoType: StructType<{
+    name: StringType;
+    deployed: BooleanType;
+    packageName: OptionType<StringType>;
+    packageVersion: OptionType<StringType>;
+}>;
+/**
+ * Request to deploy a package to a workspace.
+ *
+ * @property packageName - Package name to deploy
+ * @property packageVersion - Package version to deploy
+ */
+export declare const WorkspaceDeployRequestType: StructType<{
+    packageName: StringType;
+    packageVersion: StringType;
+}>;
+/**
+ * Alternative deploy request using package reference string.
+ *
+ * @property packageRef - Package reference in format "name" or "name@version"
+ */
+export declare const DeployRequestType: StructType<{
+    packageRef: StringType;
+}>;
+/**
+ * Dataset status variant.
+ *
+ * - `unset`: No value assigned to this dataset
+ * - `stale`: Value exists but is outdated (upstream changed)
+ * - `up-to-date`: Value is current
+ */
+export declare const DatasetStatusType: VariantType<{
+    unset: NullType;
+    stale: NullType;
+    'up-to-date': NullType;
+}>;
+/** Task completed successfully. @property cached - True if result was from cache */
+export declare const TaskStatusUpToDateType: StructType<{
+    cached: BooleanType;
+}>;
+/** Task waiting on dependencies. @property reason - Human-readable wait reason */
+export declare const TaskStatusWaitingType: StructType<{
+    reason: StringType;
+}>;
+/** Task currently executing. */
+export declare const TaskStatusInProgressType: StructType<{
+    /** Process ID of the running task */
+    pid: OptionType<IntegerType>;
+    /** ISO timestamp when execution started */
+    startedAt: OptionType<StringType>;
+}>;
+/** Task exited with non-zero code. */
+export declare const TaskStatusFailedType: StructType<{
+    /** Process exit code */
+    exitCode: IntegerType;
+    /** ISO timestamp when task completed */
+    completedAt: OptionType<StringType>;
+}>;
+/** Task encountered an internal error. */
+export declare const TaskStatusErrorType: StructType<{
+    /** Error message */
+    message: StringType;
+    /** ISO timestamp when error occurred */
+    completedAt: OptionType<StringType>;
+}>;
+/** Task was running but process is no longer alive. */
+export declare const TaskStatusStaleRunningType: StructType<{
+    /** Last known process ID */
+    pid: OptionType<IntegerType>;
+    /** ISO timestamp when execution started */
+    startedAt: OptionType<StringType>;
+}>;
+/**
+ * Task execution status variant.
+ *
+ * - `up-to-date`: Task completed successfully (cached indicates if from cache)
+ * - `ready`: Task is ready to run (all inputs available)
+ * - `waiting`: Task waiting on upstream dependencies
+ * - `in-progress`: Task currently executing
+ * - `failed`: Task exited with non-zero exit code
+ * - `error`: Internal error during task execution
+ * - `stale-running`: Task was marked running but process died
+ */
+export declare const TaskStatusType: VariantType<{
+    'up-to-date': StructType<{
+        cached: BooleanType;
+    }>;
+    ready: NullType;
+    waiting: StructType<{
+        reason: StringType;
+    }>;
+    'in-progress': StructType<{
+        /** Process ID of the running task */
+        pid: OptionType<IntegerType>;
+        /** ISO timestamp when execution started */
+        startedAt: OptionType<StringType>;
+    }>;
+    failed: StructType<{
+        /** Process exit code */
+        exitCode: IntegerType;
+        /** ISO timestamp when task completed */
+        completedAt: OptionType<StringType>;
+    }>;
+    error: StructType<{
+        /** Error message */
+        message: StringType;
+        /** ISO timestamp when error occurred */
+        completedAt: OptionType<StringType>;
+    }>;
+    'stale-running': StructType<{
+        /** Last known process ID */
+        pid: OptionType<IntegerType>;
+        /** ISO timestamp when execution started */
+        startedAt: OptionType<StringType>;
+    }>;
+}>;
+/**
+ * Status information for a single dataset.
+ *
+ * @property path - Dataset path (e.g., ".inputs.config" or ".tasks.foo.output")
+ * @property status - Current status (unset, stale, or up-to-date)
+ * @property hash - SHA256 hash of current value (if set)
+ * @property isTaskOutput - True if this dataset is produced by a task
+ * @property producedBy - Name of task that produces this dataset (if isTaskOutput)
+ */
+export declare const DatasetStatusInfoType: StructType<{
+    path: StringType;
+    status: VariantType<{
+        unset: NullType;
+        stale: NullType;
+        'up-to-date': NullType;
+    }>;
+    hash: OptionType<StringType>;
+    isTaskOutput: BooleanType;
+    producedBy: OptionType<StringType>;
+}>;
+/**
+ * Status information for a single task.
+ *
+ * @property name - Task name
+ * @property hash - Task definition hash (changes when task code changes)
+ * @property status - Current execution status
+ * @property inputs - Dataset paths this task reads from
+ * @property output - Dataset path this task writes to
+ * @property dependsOn - Names of tasks that must complete before this one
+ */
+export declare const TaskStatusInfoType: StructType<{
+    name: StringType;
+    hash: StringType;
+    status: VariantType<{
+        'up-to-date': StructType<{
+            cached: BooleanType;
+        }>;
+        ready: NullType;
+        waiting: StructType<{
+            reason: StringType;
+        }>;
+        'in-progress': StructType<{
+            /** Process ID of the running task */
+            pid: OptionType<IntegerType>;
+            /** ISO timestamp when execution started */
+            startedAt: OptionType<StringType>;
+        }>;
+        failed: StructType<{
+            /** Process exit code */
+            exitCode: IntegerType;
+            /** ISO timestamp when task completed */
+            completedAt: OptionType<StringType>;
+        }>;
+        error: StructType<{
+            /** Error message */
+            message: StringType;
+            /** ISO timestamp when error occurred */
+            completedAt: OptionType<StringType>;
+        }>;
+        'stale-running': StructType<{
+            /** Last known process ID */
+            pid: OptionType<IntegerType>;
+            /** ISO timestamp when execution started */
+            startedAt: OptionType<StringType>;
+        }>;
+    }>;
+    inputs: ArrayType<StringType>;
+    output: StringType;
+    dependsOn: ArrayType<StringType>;
+}>;
+/**
+ * Summary counts for workspace status.
+ */
+export declare const WorkspaceStatusSummaryType: StructType<{
+    /** Dataset status counts */
+    datasets: StructType<{
+        total: IntegerType;
+        unset: IntegerType;
+        stale: IntegerType;
+        upToDate: IntegerType;
+    }>;
+    /** Task status counts */
+    tasks: StructType<{
+        total: IntegerType;
+        upToDate: IntegerType;
+        ready: IntegerType;
+        waiting: IntegerType;
+        inProgress: IntegerType;
+        failed: IntegerType;
+        error: IntegerType;
+        staleRunning: IntegerType;
+    }>;
+}>;
+/**
+ * Complete workspace status including all datasets, tasks, and summary.
+ *
+ * @property workspace - Workspace name
+ * @property lock - Information about current lock holder (if locked)
+ * @property datasets - Status of all datasets in the workspace
+ * @property tasks - Status of all tasks in the workspace
+ * @property summary - Aggregated counts by status
+ */
+export declare const WorkspaceStatusResultType: StructType<{
+    workspace: StringType;
+    lock: OptionType<StructType<{
+        pid: IntegerType;
+        acquiredAt: StringType;
+        bootId: OptionType<StringType>;
+        command: OptionType<StringType>;
+    }>>;
+    datasets: ArrayType<StructType<{
+        path: StringType;
+        status: VariantType<{
+            unset: NullType;
+            stale: NullType;
+            'up-to-date': NullType;
+        }>;
+        hash: OptionType<StringType>;
+        isTaskOutput: BooleanType;
+        producedBy: OptionType<StringType>;
+    }>>;
+    tasks: ArrayType<StructType<{
+        name: StringType;
+        hash: StringType;
+        status: VariantType<{
+            'up-to-date': StructType<{
+                cached: BooleanType;
+            }>;
+            ready: NullType;
+            waiting: StructType<{
+                reason: StringType;
+            }>;
+            'in-progress': StructType<{
+                /** Process ID of the running task */
+                pid: OptionType<IntegerType>;
+                /** ISO timestamp when execution started */
+                startedAt: OptionType<StringType>;
+            }>;
+            failed: StructType<{
+                /** Process exit code */
+                exitCode: IntegerType;
+                /** ISO timestamp when task completed */
+                completedAt: OptionType<StringType>;
+            }>;
+            error: StructType<{
+                /** Error message */
+                message: StringType;
+                /** ISO timestamp when error occurred */
+                completedAt: OptionType<StringType>;
+            }>;
+            'stale-running': StructType<{
+                /** Last known process ID */
+                pid: OptionType<IntegerType>;
+                /** ISO timestamp when execution started */
+                startedAt: OptionType<StringType>;
+            }>;
+        }>;
+        inputs: ArrayType<StringType>;
+        output: StringType;
+        dependsOn: ArrayType<StringType>;
+    }>>;
+    summary: StructType<{
+        /** Dataset status counts */
+        datasets: StructType<{
+            total: IntegerType;
+            unset: IntegerType;
+            stale: IntegerType;
+            upToDate: IntegerType;
+        }>;
+        /** Task status counts */
+        tasks: StructType<{
+            total: IntegerType;
+            upToDate: IntegerType;
+            ready: IntegerType;
+            waiting: IntegerType;
+            inProgress: IntegerType;
+            failed: IntegerType;
+            error: IntegerType;
+            staleRunning: IntegerType;
+        }>;
+    }>;
+}>;
+export declare const TaskListItemType: StructType<{
+    name: StringType;
+    hash: StringType;
+}>;
+export declare const TaskInfoType: StructType<{
+    name: StringType;
+    hash: StringType;
+}>;
+export declare const TaskDetailsType: StructType<{
+    name: StringType;
+    hash: StringType;
+    commandIr: StringType;
+    inputs: ArrayType<ArrayType<VariantType<{
+        field: StringType;
+    }>>>;
+    output: ArrayType<VariantType<{
+        field: StringType;
+    }>>;
+}>;
+export declare const DataflowRequestType: StructType<{
+    concurrency: OptionType<IntegerType>;
+    force: BooleanType;
+    filter: OptionType<StringType>;
+}>;
+export declare const StartRequestType: StructType<{
+    concurrency: OptionType<IntegerType>;
+    force: BooleanType;
+    filter: OptionType<StringType>;
+}>;
+export declare const GraphTaskType: StructType<{
+    name: StringType;
+    hash: StringType;
+    inputs: ArrayType<StringType>;
+    output: StringType;
+    dependsOn: ArrayType<StringType>;
+}>;
+export declare const DataflowGraphType: StructType<{
+    tasks: ArrayType<StructType<{
+        name: StringType;
+        hash: StringType;
+        inputs: ArrayType<StringType>;
+        output: StringType;
+        dependsOn: ArrayType<StringType>;
+    }>>;
+}>;
+export declare const LogChunkType: StructType<{
+    data: StringType;
+    offset: IntegerType;
+    size: IntegerType;
+    totalSize: IntegerType;
+    complete: BooleanType;
+}>;
+export declare const TaskExecutionResultType: StructType<{
+    name: StringType;
+    cached: BooleanType;
+    state: VariantType<{
+        success: NullType;
+        failed: StructType<{
+            exitCode: IntegerType;
+        }>;
+        error: StructType<{
+            message: StringType;
+        }>;
+        skipped: NullType;
+    }>;
+    duration: FloatType;
+}>;
+export declare const DataflowResultType: StructType<{
+    success: BooleanType;
+    executed: IntegerType;
+    cached: IntegerType;
+    failed: IntegerType;
+    skipped: IntegerType;
+    tasks: ArrayType<StructType<{
+        name: StringType;
+        cached: BooleanType;
+        state: VariantType<{
+            success: NullType;
+            failed: StructType<{
+                exitCode: IntegerType;
+            }>;
+            error: StructType<{
+                message: StringType;
+            }>;
+            skipped: NullType;
+        }>;
+        duration: FloatType;
+    }>>;
+    duration: FloatType;
+}>;
+export type Error = ValueTypeOf<typeof ErrorType>;
+export type RepositoryStatus = ValueTypeOf<typeof RepositoryStatusType>;
+export type GcRequest = ValueTypeOf<typeof GcRequestType>;
+export type GcResult = ValueTypeOf<typeof GcResultType>;
+export type PackageListItem = ValueTypeOf<typeof PackageListItemType>;
+export type PackageImportResult = ValueTypeOf<typeof PackageImportResultType>;
+export type PackageInfo = ValueTypeOf<typeof PackageInfoType>;
+export type PackageDetails = ValueTypeOf<typeof PackageDetailsType>;
+export type WorkspaceInfo = ValueTypeOf<typeof WorkspaceInfoType>;
+export type WorkspaceCreateRequest = ValueTypeOf<typeof WorkspaceCreateRequestType>;
+export type WorkspaceDeployRequest = ValueTypeOf<typeof WorkspaceDeployRequestType>;
+export type DatasetStatus = ValueTypeOf<typeof DatasetStatusType>;
+export type TaskStatus = ValueTypeOf<typeof TaskStatusType>;
+export type DatasetStatusInfo = ValueTypeOf<typeof DatasetStatusInfoType>;
+export type TaskStatusInfo = ValueTypeOf<typeof TaskStatusInfoType>;
+export type WorkspaceStatusSummary = ValueTypeOf<typeof WorkspaceStatusSummaryType>;
+export type WorkspaceStatusResult = ValueTypeOf<typeof WorkspaceStatusResultType>;
+export type TaskListItem = ValueTypeOf<typeof TaskListItemType>;
+export type TaskDetails = ValueTypeOf<typeof TaskDetailsType>;
+export type DataflowRequest = ValueTypeOf<typeof DataflowRequestType>;
+export type GraphTask = ValueTypeOf<typeof GraphTaskType>;
+export type DataflowGraph = ValueTypeOf<typeof DataflowGraphType>;
+export type LogChunk = ValueTypeOf<typeof LogChunkType>;
+export type TaskExecutionResult = ValueTypeOf<typeof TaskExecutionResultType>;
+export type DataflowResult = ValueTypeOf<typeof DataflowResultType>;
+export declare const ApiTypes: {
+    readonly ErrorType: VariantType<{
+        workspace_not_found: StructType<{
+            workspace: StringType;
+        }>;
+        workspace_not_deployed: StructType<{
+            workspace: StringType;
+        }>;
+        workspace_exists: StructType<{
+            workspace: StringType;
+        }>;
+        workspace_locked: StructType<{
+            workspace: StringType;
+            holder: VariantType<{
+                unknown: NullType;
+                known: StructType<{
+                    pid: IntegerType;
+                    acquiredAt: StringType;
+                    bootId: OptionType<StringType>;
+                    command: OptionType<StringType>;
+                }>;
+            }>;
+        }>;
+        package_not_found: StructType<{
+            packageName: StringType;
+            version: OptionType<StringType>;
+        }>;
+        package_exists: StructType<{
+            packageName: StringType;
+            version: StringType;
+        }>;
+        package_invalid: StructType<{
+            reason: StringType;
+        }>;
+        dataset_not_found: StructType<{
+            workspace: StringType;
+            path: StringType;
+        }>;
+        task_not_found: StructType<{
+            task: StringType;
+        }>;
+        object_not_found: StructType<{
+            hash: StringType;
+        }>;
+        dataflow_error: StructType<{
+            message: StringType;
+        }>;
+        dataflow_aborted: NullType;
+        permission_denied: StructType<{
+            path: StringType;
+        }>;
+        internal: StructType<{
+            message: StringType;
+        }>;
+    }>;
+    readonly WorkspaceNotFoundErrorType: StructType<{
+        workspace: StringType;
+    }>;
+    readonly WorkspaceNotDeployedErrorType: StructType<{
+        workspace: StringType;
+    }>;
+    readonly WorkspaceExistsErrorType: StructType<{
+        workspace: StringType;
+    }>;
+    readonly WorkspaceLockedErrorType: StructType<{
+        workspace: StringType;
+        holder: VariantType<{
+            unknown: NullType;
+            known: StructType<{
+                pid: IntegerType;
+                acquiredAt: StringType;
+                bootId: OptionType<StringType>;
+                command: OptionType<StringType>;
+            }>;
+        }>;
+    }>;
+    readonly LockHolderType: StructType<{
+        pid: IntegerType;
+        acquiredAt: StringType;
+        bootId: OptionType<StringType>;
+        command: OptionType<StringType>;
+    }>;
+    readonly PackageNotFoundErrorType: StructType<{
+        packageName: StringType;
+        version: OptionType<StringType>;
+    }>;
+    readonly PackageExistsErrorType: StructType<{
+        packageName: StringType;
+        version: StringType;
+    }>;
+    readonly PackageInvalidErrorType: StructType<{
+        reason: StringType;
+    }>;
+    readonly DatasetNotFoundErrorType: StructType<{
+        workspace: StringType;
+        path: StringType;
+    }>;
+    readonly TaskNotFoundErrorType: StructType<{
+        task: StringType;
+    }>;
+    readonly ObjectNotFoundErrorType: StructType<{
+        hash: StringType;
+    }>;
+    readonly DataflowErrorType: StructType<{
+        message: StringType;
+    }>;
+    readonly PermissionDeniedErrorType: StructType<{
+        path: StringType;
+    }>;
+    readonly InternalErrorType: StructType<{
+        message: StringType;
+    }>;
+    readonly ResponseType: <T extends EastType>(successType: T) => VariantType<{
+        success: T;
+        error: VariantType<{
+            workspace_not_found: StructType<{
+                workspace: StringType;
+            }>;
+            workspace_not_deployed: StructType<{
+                workspace: StringType;
+            }>;
+            workspace_exists: StructType<{
+                workspace: StringType;
+            }>;
+            workspace_locked: StructType<{
+                workspace: StringType;
+                holder: VariantType<{
+                    unknown: NullType;
+                    known: StructType<{
+                        pid: IntegerType;
+                        acquiredAt: StringType;
+                        bootId: OptionType<StringType>;
+                        command: OptionType<StringType>;
+                    }>;
+                }>;
+            }>;
+            package_not_found: StructType<{
+                packageName: StringType;
+                version: OptionType<StringType>;
+            }>;
+            package_exists: StructType<{
+                packageName: StringType;
+                version: StringType;
+            }>;
+            package_invalid: StructType<{
+                reason: StringType;
+            }>;
+            dataset_not_found: StructType<{
+                workspace: StringType;
+                path: StringType;
+            }>;
+            task_not_found: StructType<{
+                task: StringType;
+            }>;
+            object_not_found: StructType<{
+                hash: StringType;
+            }>;
+            dataflow_error: StructType<{
+                message: StringType;
+            }>;
+            dataflow_aborted: NullType;
+            permission_denied: StructType<{
+                path: StringType;
+            }>;
+            internal: StructType<{
+                message: StringType;
+            }>;
+        }>;
+    }>;
+    readonly RepositoryStatusType: StructType<{
+        path: StringType;
+        objectCount: IntegerType;
+        packageCount: IntegerType;
+        workspaceCount: IntegerType;
+    }>;
+    readonly GcRequestType: StructType<{
+        dryRun: BooleanType;
+        minAge: OptionType<IntegerType>;
+    }>;
+    readonly GcResultType: StructType<{
+        deletedObjects: IntegerType;
+        deletedPartials: IntegerType;
+        retainedObjects: IntegerType;
+        skippedYoung: IntegerType;
+        bytesFreed: IntegerType;
+    }>;
+    readonly PackageListItemType: StructType<{
+        name: StringType;
+        version: StringType;
+    }>;
+    readonly PackageImportResultType: StructType<{
+        name: StringType;
+        version: StringType;
+        packageHash: StringType;
+        objectCount: IntegerType;
+    }>;
+    readonly PackageInfoType: StructType<{
+        name: StringType;
+        version: StringType;
+        hash: StringType;
+    }>;
+    readonly PackageDetailsType: StructType<{
+        name: StringType;
+        version: StringType;
+        hash: StringType;
+        tasks: ArrayType<StringType>;
+        dataStructure: import("@elaraai/east").RecursiveType<VariantType<{
+            value: import("@elaraai/east").RecursiveType<VariantType<{
+                Never: import("@elaraai/east").NullType;
+                Null: import("@elaraai/east").NullType;
+                Boolean: import("@elaraai/east").NullType;
+                Integer: import("@elaraai/east").NullType;
+                Float: import("@elaraai/east").NullType;
+                String: import("@elaraai/east").NullType;
+                DateTime: import("@elaraai/east").NullType;
+                Blob: import("@elaraai/east").NullType;
+                Ref: import("@elaraai/east").RecursiveTypeMarker;
+                Array: import("@elaraai/east").RecursiveTypeMarker;
+                Set: import("@elaraai/east").RecursiveTypeMarker;
+                Dict: import("@elaraai/east").StructType<{
+                    key: import("@elaraai/east").RecursiveTypeMarker;
+                    value: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                Struct: ArrayType<import("@elaraai/east").StructType<{
+                    name: StringType;
+                    type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                Variant: ArrayType<import("@elaraai/east").StructType<{
+                    name: StringType;
+                    type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                Recursive: import("@elaraai/east").IntegerType;
+                Function: import("@elaraai/east").StructType<{
+                    inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                AsyncFunction: import("@elaraai/east").StructType<{
+                    inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>>;
+            struct: import("@elaraai/east").DictType<StringType, import("@elaraai/east").RecursiveTypeMarker>;
+        }>>;
+    }>;
+    readonly WorkspaceCreateRequestType: StructType<{
+        name: StringType;
+    }>;
+    readonly WorkspaceInfoType: StructType<{
+        name: StringType;
+        deployed: BooleanType;
+        packageName: OptionType<StringType>;
+        packageVersion: OptionType<StringType>;
+    }>;
+    readonly WorkspaceDeployRequestType: StructType<{
+        packageName: StringType;
+        packageVersion: StringType;
+    }>;
+    readonly DeployRequestType: StructType<{
+        packageRef: StringType;
+    }>;
+    readonly DatasetStatusType: VariantType<{
+        unset: NullType;
+        stale: NullType;
+        'up-to-date': NullType;
+    }>;
+    readonly TaskStatusType: VariantType<{
+        'up-to-date': StructType<{
+            cached: BooleanType;
+        }>;
+        ready: NullType;
+        waiting: StructType<{
+            reason: StringType;
+        }>;
+        'in-progress': StructType<{
+            /** Process ID of the running task */
+            pid: OptionType<IntegerType>;
+            /** ISO timestamp when execution started */
+            startedAt: OptionType<StringType>;
+        }>;
+        failed: StructType<{
+            /** Process exit code */
+            exitCode: IntegerType;
+            /** ISO timestamp when task completed */
+            completedAt: OptionType<StringType>;
+        }>;
+        error: StructType<{
+            /** Error message */
+            message: StringType;
+            /** ISO timestamp when error occurred */
+            completedAt: OptionType<StringType>;
+        }>;
+        'stale-running': StructType<{
+            /** Last known process ID */
+            pid: OptionType<IntegerType>;
+            /** ISO timestamp when execution started */
+            startedAt: OptionType<StringType>;
+        }>;
+    }>;
+    readonly TaskStatusUpToDateType: StructType<{
+        cached: BooleanType;
+    }>;
+    readonly TaskStatusWaitingType: StructType<{
+        reason: StringType;
+    }>;
+    readonly TaskStatusInProgressType: StructType<{
+        /** Process ID of the running task */
+        pid: OptionType<IntegerType>;
+        /** ISO timestamp when execution started */
+        startedAt: OptionType<StringType>;
+    }>;
+    readonly TaskStatusFailedType: StructType<{
+        /** Process exit code */
+        exitCode: IntegerType;
+        /** ISO timestamp when task completed */
+        completedAt: OptionType<StringType>;
+    }>;
+    readonly TaskStatusErrorType: StructType<{
+        /** Error message */
+        message: StringType;
+        /** ISO timestamp when error occurred */
+        completedAt: OptionType<StringType>;
+    }>;
+    readonly TaskStatusStaleRunningType: StructType<{
+        /** Last known process ID */
+        pid: OptionType<IntegerType>;
+        /** ISO timestamp when execution started */
+        startedAt: OptionType<StringType>;
+    }>;
+    readonly DatasetStatusInfoType: StructType<{
+        path: StringType;
+        status: VariantType<{
+            unset: NullType;
+            stale: NullType;
+            'up-to-date': NullType;
+        }>;
+        hash: OptionType<StringType>;
+        isTaskOutput: BooleanType;
+        producedBy: OptionType<StringType>;
+    }>;
+    readonly TaskStatusInfoType: StructType<{
+        name: StringType;
+        hash: StringType;
+        status: VariantType<{
+            'up-to-date': StructType<{
+                cached: BooleanType;
+            }>;
+            ready: NullType;
+            waiting: StructType<{
+                reason: StringType;
+            }>;
+            'in-progress': StructType<{
+                /** Process ID of the running task */
+                pid: OptionType<IntegerType>;
+                /** ISO timestamp when execution started */
+                startedAt: OptionType<StringType>;
+            }>;
+            failed: StructType<{
+                /** Process exit code */
+                exitCode: IntegerType;
+                /** ISO timestamp when task completed */
+                completedAt: OptionType<StringType>;
+            }>;
+            error: StructType<{
+                /** Error message */
+                message: StringType;
+                /** ISO timestamp when error occurred */
+                completedAt: OptionType<StringType>;
+            }>;
+            'stale-running': StructType<{
+                /** Last known process ID */
+                pid: OptionType<IntegerType>;
+                /** ISO timestamp when execution started */
+                startedAt: OptionType<StringType>;
+            }>;
+        }>;
+        inputs: ArrayType<StringType>;
+        output: StringType;
+        dependsOn: ArrayType<StringType>;
+    }>;
+    readonly WorkspaceStatusSummaryType: StructType<{
+        /** Dataset status counts */
+        datasets: StructType<{
+            total: IntegerType;
+            unset: IntegerType;
+            stale: IntegerType;
+            upToDate: IntegerType;
+        }>;
+        /** Task status counts */
+        tasks: StructType<{
+            total: IntegerType;
+            upToDate: IntegerType;
+            ready: IntegerType;
+            waiting: IntegerType;
+            inProgress: IntegerType;
+            failed: IntegerType;
+            error: IntegerType;
+            staleRunning: IntegerType;
+        }>;
+    }>;
+    readonly WorkspaceStatusResultType: StructType<{
+        workspace: StringType;
+        lock: OptionType<StructType<{
+            pid: IntegerType;
+            acquiredAt: StringType;
+            bootId: OptionType<StringType>;
+            command: OptionType<StringType>;
+        }>>;
+        datasets: ArrayType<StructType<{
+            path: StringType;
+            status: VariantType<{
+                unset: NullType;
+                stale: NullType;
+                'up-to-date': NullType;
+            }>;
+            hash: OptionType<StringType>;
+            isTaskOutput: BooleanType;
+            producedBy: OptionType<StringType>;
+        }>>;
+        tasks: ArrayType<StructType<{
+            name: StringType;
+            hash: StringType;
+            status: VariantType<{
+                'up-to-date': StructType<{
+                    cached: BooleanType;
+                }>;
+                ready: NullType;
+                waiting: StructType<{
+                    reason: StringType;
+                }>;
+                'in-progress': StructType<{
+                    /** Process ID of the running task */
+                    pid: OptionType<IntegerType>;
+                    /** ISO timestamp when execution started */
+                    startedAt: OptionType<StringType>;
+                }>;
+                failed: StructType<{
+                    /** Process exit code */
+                    exitCode: IntegerType;
+                    /** ISO timestamp when task completed */
+                    completedAt: OptionType<StringType>;
+                }>;
+                error: StructType<{
+                    /** Error message */
+                    message: StringType;
+                    /** ISO timestamp when error occurred */
+                    completedAt: OptionType<StringType>;
+                }>;
+                'stale-running': StructType<{
+                    /** Last known process ID */
+                    pid: OptionType<IntegerType>;
+                    /** ISO timestamp when execution started */
+                    startedAt: OptionType<StringType>;
+                }>;
+            }>;
+            inputs: ArrayType<StringType>;
+            output: StringType;
+            dependsOn: ArrayType<StringType>;
+        }>>;
+        summary: StructType<{
+            /** Dataset status counts */
+            datasets: StructType<{
+                total: IntegerType;
+                unset: IntegerType;
+                stale: IntegerType;
+                upToDate: IntegerType;
+            }>;
+            /** Task status counts */
+            tasks: StructType<{
+                total: IntegerType;
+                upToDate: IntegerType;
+                ready: IntegerType;
+                waiting: IntegerType;
+                inProgress: IntegerType;
+                failed: IntegerType;
+                error: IntegerType;
+                staleRunning: IntegerType;
+            }>;
+        }>;
+    }>;
+    readonly TaskListItemType: StructType<{
+        name: StringType;
+        hash: StringType;
+    }>;
+    readonly TaskInfoType: StructType<{
+        name: StringType;
+        hash: StringType;
+    }>;
+    readonly TaskDetailsType: StructType<{
+        name: StringType;
+        hash: StringType;
+        commandIr: StringType;
+        inputs: ArrayType<ArrayType<VariantType<{
+            field: StringType;
+        }>>>;
+        output: ArrayType<VariantType<{
+            field: StringType;
+        }>>;
+    }>;
+    readonly DataflowRequestType: StructType<{
+        concurrency: OptionType<IntegerType>;
+        force: BooleanType;
+        filter: OptionType<StringType>;
+    }>;
+    readonly StartRequestType: StructType<{
+        concurrency: OptionType<IntegerType>;
+        force: BooleanType;
+        filter: OptionType<StringType>;
+    }>;
+    readonly GraphTaskType: StructType<{
+        name: StringType;
+        hash: StringType;
+        inputs: ArrayType<StringType>;
+        output: StringType;
+        dependsOn: ArrayType<StringType>;
+    }>;
+    readonly DataflowGraphType: StructType<{
+        tasks: ArrayType<StructType<{
+            name: StringType;
+            hash: StringType;
+            inputs: ArrayType<StringType>;
+            output: StringType;
+            dependsOn: ArrayType<StringType>;
+        }>>;
+    }>;
+    readonly LogChunkType: StructType<{
+        data: StringType;
+        offset: IntegerType;
+        size: IntegerType;
+        totalSize: IntegerType;
+        complete: BooleanType;
+    }>;
+    readonly TaskExecutionResultType: StructType<{
+        name: StringType;
+        cached: BooleanType;
+        state: VariantType<{
+            success: NullType;
+            failed: StructType<{
+                exitCode: IntegerType;
+            }>;
+            error: StructType<{
+                message: StringType;
+            }>;
+            skipped: NullType;
+        }>;
+        duration: FloatType;
+    }>;
+    readonly DataflowResultType: StructType<{
+        success: BooleanType;
+        executed: IntegerType;
+        cached: IntegerType;
+        failed: IntegerType;
+        skipped: IntegerType;
+        tasks: ArrayType<StructType<{
+            name: StringType;
+            cached: BooleanType;
+            state: VariantType<{
+                success: NullType;
+                failed: StructType<{
+                    exitCode: IntegerType;
+                }>;
+                error: StructType<{
+                    message: StringType;
+                }>;
+                skipped: NullType;
+            }>;
+            duration: FloatType;
+        }>>;
+        duration: FloatType;
+    }>;
+};
+//# sourceMappingURL=types.d.ts.map