@elaraai/e3-api-server 0.0.2-beta.3 → 0.0.2-beta.31

package/dist/src/types.d.ts

@@ -9,186 +9,204 @@
  */
 import { VariantType, StructType, ArrayType, OptionType, StringType, IntegerType, FloatType, BooleanType, NullType, type EastType, type ValueTypeOf } from '@elaraai/east';
 export declare const WorkspaceNotFoundErrorType: StructType<{
-    workspace: StringType;
+    readonly workspace: StringType;
 }>;
 export declare const WorkspaceNotDeployedErrorType: StructType<{
-    workspace: StringType;
+    readonly workspace: StringType;
 }>;
 export declare const WorkspaceExistsErrorType: StructType<{
-    workspace: StringType;
+    readonly workspace: StringType;
 }>;
 export declare const LockHolderType: StructType<{
-    pid: IntegerType;
-    acquiredAt: StringType;
-    bootId: OptionType<StringType>;
-    command: OptionType<StringType>;
+    readonly pid: IntegerType;
+    readonly acquiredAt: StringType;
+    readonly bootId: OptionType<StringType>;
+    readonly 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>;
+    readonly workspace: StringType;
+    readonly holder: VariantType<{
+        readonly unknown: NullType;
+        readonly known: StructType<{
+            readonly pid: IntegerType;
+            readonly acquiredAt: StringType;
+            readonly bootId: OptionType<StringType>;
+            readonly command: OptionType<StringType>;
         }>;
     }>;
 }>;
 export declare const PackageNotFoundErrorType: StructType<{
-    packageName: StringType;
-    version: OptionType<StringType>;
+    readonly packageName: StringType;
+    readonly version: OptionType<StringType>;
 }>;
 export declare const PackageExistsErrorType: StructType<{
-    packageName: StringType;
-    version: StringType;
+    readonly packageName: StringType;
+    readonly version: StringType;
 }>;
 export declare const PackageInvalidErrorType: StructType<{
-    reason: StringType;
+    readonly reason: StringType;
 }>;
 export declare const DatasetNotFoundErrorType: StructType<{
-    workspace: StringType;
-    path: StringType;
+    readonly workspace: StringType;
+    readonly path: StringType;
 }>;
 export declare const TaskNotFoundErrorType: StructType<{
-    task: StringType;
+    readonly task: StringType;
+}>;
+export declare const ExecutionNotFoundErrorType: StructType<{
+    readonly task: StringType;
 }>;
 export declare const ObjectNotFoundErrorType: StructType<{
-    hash: StringType;
+    readonly hash: StringType;
 }>;
 export declare const DataflowErrorType: StructType<{
-    message: StringType;
+    readonly message: StringType;
 }>;
 export declare const PermissionDeniedErrorType: StructType<{
-    path: StringType;
+    readonly path: StringType;
 }>;
 export declare const InternalErrorType: StructType<{
-    message: StringType;
+    readonly message: StringType;
+}>;
+export declare const RepositoryNotFoundErrorType: StructType<{
+    readonly repo: 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>;
+    readonly repository_not_found: StructType<{
+        readonly repo: StringType;
+    }>;
+    readonly workspace_not_found: StructType<{
+        readonly workspace: StringType;
+    }>;
+    readonly workspace_not_deployed: StructType<{
+        readonly workspace: StringType;
+    }>;
+    readonly workspace_exists: StructType<{
+        readonly workspace: StringType;
+    }>;
+    readonly workspace_locked: StructType<{
+        readonly workspace: StringType;
+        readonly holder: VariantType<{
+            readonly unknown: NullType;
+            readonly known: StructType<{
+                readonly pid: IntegerType;
+                readonly acquiredAt: StringType;
+                readonly bootId: OptionType<StringType>;
+                readonly command: OptionType<StringType>;
             }>;
         }>;
     }>;
-    package_not_found: StructType<{
-        packageName: StringType;
-        version: OptionType<StringType>;
+    readonly package_not_found: StructType<{
+        readonly packageName: StringType;
+        readonly version: OptionType<StringType>;
     }>;
-    package_exists: StructType<{
-        packageName: StringType;
-        version: StringType;
+    readonly package_exists: StructType<{
+        readonly packageName: StringType;
+        readonly version: StringType;
     }>;
-    package_invalid: StructType<{
-        reason: StringType;
+    readonly package_invalid: StructType<{
+        readonly reason: StringType;
     }>;
-    dataset_not_found: StructType<{
-        workspace: StringType;
-        path: StringType;
+    readonly dataset_not_found: StructType<{
+        readonly workspace: StringType;
+        readonly path: StringType;
     }>;
-    task_not_found: StructType<{
-        task: StringType;
+    readonly task_not_found: StructType<{
+        readonly task: StringType;
     }>;
-    object_not_found: StructType<{
-        hash: StringType;
+    readonly execution_not_found: StructType<{
+        readonly task: StringType;
     }>;
-    dataflow_error: StructType<{
-        message: StringType;
+    readonly object_not_found: StructType<{
+        readonly hash: StringType;
     }>;
-    dataflow_aborted: NullType;
-    permission_denied: StructType<{
-        path: StringType;
+    readonly dataflow_error: StructType<{
+        readonly message: StringType;
     }>;
-    internal: StructType<{
-        message: StringType;
+    readonly dataflow_aborted: NullType;
+    readonly permission_denied: StructType<{
+        readonly path: StringType;
+    }>;
+    readonly internal: StructType<{
+        readonly 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>;
+    readonly success: T;
+    readonly error: VariantType<{
+        readonly repository_not_found: StructType<{
+            readonly repo: StringType;
+        }>;
+        readonly workspace_not_found: StructType<{
+            readonly workspace: StringType;
+        }>;
+        readonly workspace_not_deployed: StructType<{
+            readonly workspace: StringType;
+        }>;
+        readonly workspace_exists: StructType<{
+            readonly workspace: StringType;
+        }>;
+        readonly workspace_locked: StructType<{
+            readonly workspace: StringType;
+            readonly holder: VariantType<{
+                readonly unknown: NullType;
+                readonly known: StructType<{
+                    readonly pid: IntegerType;
+                    readonly acquiredAt: StringType;
+                    readonly bootId: OptionType<StringType>;
+                    readonly command: OptionType<StringType>;
                 }>;
             }>;
         }>;
-        package_not_found: StructType<{
-            packageName: StringType;
-            version: OptionType<StringType>;
+        readonly package_not_found: StructType<{
+            readonly packageName: StringType;
+            readonly version: OptionType<StringType>;
         }>;
-        package_exists: StructType<{
-            packageName: StringType;
-            version: StringType;
+        readonly package_exists: StructType<{
+            readonly packageName: StringType;
+            readonly version: StringType;
         }>;
-        package_invalid: StructType<{
-            reason: StringType;
+        readonly package_invalid: StructType<{
+            readonly reason: StringType;
         }>;
-        dataset_not_found: StructType<{
-            workspace: StringType;
-            path: StringType;
+        readonly dataset_not_found: StructType<{
+            readonly workspace: StringType;
+            readonly path: StringType;
         }>;
-        task_not_found: StructType<{
-            task: StringType;
+        readonly task_not_found: StructType<{
+            readonly task: StringType;
         }>;
-        object_not_found: StructType<{
-            hash: StringType;
+        readonly execution_not_found: StructType<{
+            readonly task: StringType;
         }>;
-        dataflow_error: StructType<{
-            message: StringType;
+        readonly object_not_found: StructType<{
+            readonly hash: StringType;
         }>;
-        dataflow_aborted: NullType;
-        permission_denied: StructType<{
-            path: StringType;
+        readonly dataflow_error: StructType<{
+            readonly message: StringType;
         }>;
-        internal: StructType<{
-            message: StringType;
+        readonly dataflow_aborted: NullType;
+        readonly permission_denied: StructType<{
+            readonly path: StringType;
+        }>;
+        readonly internal: StructType<{
+            readonly message: StringType;
         }>;
     }>;
 }>;
 /**
  * Repository status information.
  *
- * @property path - Absolute path to the .e3 repository directory
+ * @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;
+    readonly path: StringType;
+    readonly objectCount: IntegerType;
+    readonly packageCount: IntegerType;
+    readonly workspaceCount: IntegerType;
 }>;
 /**
  * Garbage collection request options.
@@ -197,8 +215,8 @@ export declare const RepositoryStatusType: StructType<{
  * @property minAge - Minimum age in milliseconds for objects to be considered for deletion
  */
 export declare const GcRequestType: StructType<{
-    dryRun: BooleanType;
-    minAge: OptionType<IntegerType>;
+    readonly dryRun: BooleanType;
+    readonly minAge: OptionType<IntegerType>;
 }>;
 /**
  * Garbage collection result.
@@ -210,11 +228,53 @@ export declare const GcRequestType: StructType<{
  * @property bytesFreed - Total bytes freed by deletion
  */
 export declare const GcResultType: StructType<{
-    deletedObjects: IntegerType;
-    deletedPartials: IntegerType;
-    retainedObjects: IntegerType;
-    skippedYoung: IntegerType;
-    bytesFreed: IntegerType;
+    readonly deletedObjects: IntegerType;
+    readonly deletedPartials: IntegerType;
+    readonly retainedObjects: IntegerType;
+    readonly skippedYoung: IntegerType;
+    readonly bytesFreed: IntegerType;
+}>;
+/**
+ * Status of an async operation.
+ *
+ * - `running`: Operation is in progress
+ * - `succeeded`: Operation completed successfully
+ * - `failed`: Operation failed with an error
+ */
+export declare const AsyncOperationStatusType: VariantType<{
+    readonly running: NullType;
+    readonly succeeded: NullType;
+    readonly failed: NullType;
+}>;
+/**
+ * Result of starting an async GC operation.
+ *
+ * @property executionId - Unique identifier for this GC execution (UUID locally, Step Function ARN in cloud)
+ */
+export declare const GcStartResultType: StructType<{
+    readonly executionId: StringType;
+}>;
+/**
+ * Status of an async GC operation.
+ *
+ * @property status - Current execution status
+ * @property stats - GC statistics (available when succeeded)
+ * @property error - Error message (available when failed)
+ */
+export declare const GcStatusResultType: StructType<{
+    readonly status: VariantType<{
+        readonly running: NullType;
+        readonly succeeded: NullType;
+        readonly failed: NullType;
+    }>;
+    readonly stats: OptionType<StructType<{
+        readonly deletedObjects: IntegerType;
+        readonly deletedPartials: IntegerType;
+        readonly retainedObjects: IntegerType;
+        readonly skippedYoung: IntegerType;
+        readonly bytesFreed: IntegerType;
+    }>>;
+    readonly error: OptionType<StringType>;
 }>;
 /**
  * Package list item (summary info).
@@ -223,8 +283,8 @@ export declare const GcResultType: StructType<{
  * @property version - Semantic version string
  */
 export declare const PackageListItemType: StructType<{
-    name: StringType;
-    version: StringType;
+    readonly name: StringType;
+    readonly version: StringType;
 }>;
 /**
  * Result of importing a package.
@@ -235,10 +295,10 @@ export declare const PackageListItemType: StructType<{
  * @property objectCount - Number of objects added to the repository
  */
 export declare const PackageImportResultType: StructType<{
-    name: StringType;
-    version: StringType;
-    packageHash: StringType;
-    objectCount: IntegerType;
+    readonly name: StringType;
+    readonly version: StringType;
+    readonly packageHash: StringType;
+    readonly objectCount: IntegerType;
 }>;
 /**
  * Basic package info.
@@ -248,9 +308,9 @@ export declare const PackageImportResultType: StructType<{
  * @property hash - SHA256 content hash
  */
 export declare const PackageInfoType: StructType<{
-    name: StringType;
-    version: StringType;
-    hash: StringType;
+    readonly name: StringType;
+    readonly version: StringType;
+    readonly hash: StringType;
 }>;
 /**
  * Detailed package information including structure.
@@ -262,46 +322,48 @@ export declare const PackageInfoType: StructType<{
  * @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;
+    readonly name: StringType;
+    readonly version: StringType;
+    readonly hash: StringType;
+    readonly tasks: ArrayType<StringType>;
+    readonly dataStructure: import("@elaraai/east").RecursiveType<VariantType<{
+        readonly value: import("@elaraai/east").RecursiveType<VariantType<{
+            readonly Never: import("@elaraai/east").NullType;
+            readonly Null: import("@elaraai/east").NullType;
+            readonly Boolean: import("@elaraai/east").NullType;
+            readonly Integer: import("@elaraai/east").NullType;
+            readonly Float: import("@elaraai/east").NullType;
+            readonly String: import("@elaraai/east").NullType;
+            readonly DateTime: import("@elaraai/east").NullType;
+            readonly Blob: import("@elaraai/east").NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: import("@elaraai/east").StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
             }>;
-            Struct: ArrayType<import("@elaraai/east").StructType<{
-                name: StringType;
-                type: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Struct: ArrayType<import("@elaraai/east").StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
             }>>;
-            Variant: ArrayType<import("@elaraai/east").StructType<{
-                name: StringType;
-                type: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Variant: ArrayType<import("@elaraai/east").StructType<{
+                readonly name: StringType;
+                readonly 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;
+            readonly Recursive: import("@elaraai/east").IntegerType;
+            readonly Function: import("@elaraai/east").StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
             }>;
-            AsyncFunction: import("@elaraai/east").StructType<{
-                inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
-                output: import("@elaraai/east").RecursiveTypeMarker;
+            readonly AsyncFunction: import("@elaraai/east").StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
             }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
         }>>;
-        struct: import("@elaraai/east").DictType<StringType, import("@elaraai/east").RecursiveTypeMarker>;
+        readonly struct: import("@elaraai/east").DictType<StringType, import("@elaraai/east").RecursiveTypeMarker>;
     }>>;
 }>;
 /**
@@ -310,11 +372,11 @@ export declare const PackageDetailsType: StructType<{
  * @property name - Unique workspace name
  */
 export declare const WorkspaceCreateRequestType: StructType<{
-    name: StringType;
+    readonly name: StringType;
 }>;
 /** @deprecated Use WorkspaceCreateRequestType */
 export declare const CreateWorkspaceType: StructType<{
-    name: StringType;
+    readonly name: StringType;
 }>;
 /**
  * Workspace summary information.
@@ -325,10 +387,10 @@ export declare const CreateWorkspaceType: StructType<{
  * @property packageVersion - Version of deployed package (if deployed)
  */
 export declare const WorkspaceInfoType: StructType<{
-    name: StringType;
-    deployed: BooleanType;
-    packageName: OptionType<StringType>;
-    packageVersion: OptionType<StringType>;
+    readonly name: StringType;
+    readonly deployed: BooleanType;
+    readonly packageName: OptionType<StringType>;
+    readonly packageVersion: OptionType<StringType>;
 }>;
 /**
  * Request to deploy a package to a workspace.
@@ -337,8 +399,8 @@ export declare const WorkspaceInfoType: StructType<{
  * @property packageVersion - Package version to deploy
  */
 export declare const WorkspaceDeployRequestType: StructType<{
-    packageName: StringType;
-    packageVersion: StringType;
+    readonly packageName: StringType;
+    readonly packageVersion: StringType;
 }>;
 /**
  * Alternative deploy request using package reference string.
@@ -346,7 +408,7 @@ export declare const WorkspaceDeployRequestType: StructType<{
  * @property packageRef - Package reference in format "name" or "name@version"
  */
 export declare const DeployRequestType: StructType<{
-    packageRef: StringType;
+    readonly packageRef: StringType;
 }>;
 /**
  * Dataset status variant.
@@ -356,45 +418,45 @@ export declare const DeployRequestType: StructType<{
  * - `up-to-date`: Value is current
  */
 export declare const DatasetStatusType: VariantType<{
-    unset: NullType;
-    stale: NullType;
-    'up-to-date': NullType;
+    readonly unset: NullType;
+    readonly stale: NullType;
+    readonly 'up-to-date': NullType;
 }>;
 /** Task completed successfully. @property cached - True if result was from cache */
 export declare const TaskStatusUpToDateType: StructType<{
-    cached: BooleanType;
+    readonly cached: BooleanType;
 }>;
 /** Task waiting on dependencies. @property reason - Human-readable wait reason */
 export declare const TaskStatusWaitingType: StructType<{
-    reason: StringType;
+    readonly reason: StringType;
 }>;
 /** Task currently executing. */
 export declare const TaskStatusInProgressType: StructType<{
     /** Process ID of the running task */
-    pid: OptionType<IntegerType>;
+    readonly pid: OptionType<IntegerType>;
     /** ISO timestamp when execution started */
-    startedAt: OptionType<StringType>;
+    readonly startedAt: OptionType<StringType>;
 }>;
 /** Task exited with non-zero code. */
 export declare const TaskStatusFailedType: StructType<{
     /** Process exit code */
-    exitCode: IntegerType;
+    readonly exitCode: IntegerType;
     /** ISO timestamp when task completed */
-    completedAt: OptionType<StringType>;
+    readonly completedAt: OptionType<StringType>;
 }>;
 /** Task encountered an internal error. */
 export declare const TaskStatusErrorType: StructType<{
     /** Error message */
-    message: StringType;
+    readonly message: StringType;
     /** ISO timestamp when error occurred */
-    completedAt: OptionType<StringType>;
+    readonly completedAt: OptionType<StringType>;
 }>;
 /** Task was running but process is no longer alive. */
 export declare const TaskStatusStaleRunningType: StructType<{
     /** Last known process ID */
-    pid: OptionType<IntegerType>;
+    readonly pid: OptionType<IntegerType>;
     /** ISO timestamp when execution started */
-    startedAt: OptionType<StringType>;
+    readonly startedAt: OptionType<StringType>;
 }>;
 /**
  * Task execution status variant.
@@ -408,36 +470,36 @@ export declare const TaskStatusStaleRunningType: StructType<{
  * - `stale-running`: Task was marked running but process died
  */
 export declare const TaskStatusType: VariantType<{
-    'up-to-date': StructType<{
-        cached: BooleanType;
+    readonly 'up-to-date': StructType<{
+        readonly cached: BooleanType;
     }>;
-    ready: NullType;
-    waiting: StructType<{
-        reason: StringType;
+    readonly ready: NullType;
+    readonly waiting: StructType<{
+        readonly reason: StringType;
     }>;
-    'in-progress': StructType<{
+    readonly 'in-progress': StructType<{
         /** Process ID of the running task */
-        pid: OptionType<IntegerType>;
+        readonly pid: OptionType<IntegerType>;
         /** ISO timestamp when execution started */
-        startedAt: OptionType<StringType>;
+        readonly startedAt: OptionType<StringType>;
     }>;
-    failed: StructType<{
+    readonly failed: StructType<{
         /** Process exit code */
-        exitCode: IntegerType;
+        readonly exitCode: IntegerType;
         /** ISO timestamp when task completed */
-        completedAt: OptionType<StringType>;
+        readonly completedAt: OptionType<StringType>;
     }>;
-    error: StructType<{
+    readonly error: StructType<{
         /** Error message */
-        message: StringType;
+        readonly message: StringType;
         /** ISO timestamp when error occurred */
-        completedAt: OptionType<StringType>;
+        readonly completedAt: OptionType<StringType>;
     }>;
-    'stale-running': StructType<{
+    readonly 'stale-running': StructType<{
         /** Last known process ID */
-        pid: OptionType<IntegerType>;
+        readonly pid: OptionType<IntegerType>;
         /** ISO timestamp when execution started */
-        startedAt: OptionType<StringType>;
+        readonly startedAt: OptionType<StringType>;
     }>;
 }>;
 /**
@@ -450,15 +512,15 @@ export declare const TaskStatusType: VariantType<{
  * @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>;
+    readonly path: StringType;
+    readonly status: VariantType<{
+        readonly unset: NullType;
+        readonly stale: NullType;
+        readonly 'up-to-date': NullType;
+    }>;
+    readonly hash: OptionType<StringType>;
+    readonly isTaskOutput: BooleanType;
+    readonly producedBy: OptionType<StringType>;
 }>;
 /**
  * Status information for a single task.
@@ -471,66 +533,66 @@ export declare const DatasetStatusInfoType: StructType<{
  * @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;
+    readonly name: StringType;
+    readonly hash: StringType;
+    readonly status: VariantType<{
+        readonly 'up-to-date': StructType<{
+            readonly cached: BooleanType;
         }>;
-        ready: NullType;
-        waiting: StructType<{
-            reason: StringType;
+        readonly ready: NullType;
+        readonly waiting: StructType<{
+            readonly reason: StringType;
         }>;
-        'in-progress': StructType<{
+        readonly 'in-progress': StructType<{
             /** Process ID of the running task */
-            pid: OptionType<IntegerType>;
+            readonly pid: OptionType<IntegerType>;
             /** ISO timestamp when execution started */
-            startedAt: OptionType<StringType>;
+            readonly startedAt: OptionType<StringType>;
         }>;
-        failed: StructType<{
+        readonly failed: StructType<{
             /** Process exit code */
-            exitCode: IntegerType;
+            readonly exitCode: IntegerType;
             /** ISO timestamp when task completed */
-            completedAt: OptionType<StringType>;
+            readonly completedAt: OptionType<StringType>;
         }>;
-        error: StructType<{
+        readonly error: StructType<{
             /** Error message */
-            message: StringType;
+            readonly message: StringType;
             /** ISO timestamp when error occurred */
-            completedAt: OptionType<StringType>;
+            readonly completedAt: OptionType<StringType>;
         }>;
-        'stale-running': StructType<{
+        readonly 'stale-running': StructType<{
             /** Last known process ID */
-            pid: OptionType<IntegerType>;
+            readonly pid: OptionType<IntegerType>;
             /** ISO timestamp when execution started */
-            startedAt: OptionType<StringType>;
+            readonly startedAt: OptionType<StringType>;
         }>;
     }>;
-    inputs: ArrayType<StringType>;
-    output: StringType;
-    dependsOn: ArrayType<StringType>;
+    readonly inputs: ArrayType<StringType>;
+    readonly output: StringType;
+    readonly 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;
+    readonly datasets: StructType<{
+        readonly total: IntegerType;
+        readonly unset: IntegerType;
+        readonly stale: IntegerType;
+        readonly upToDate: IntegerType;
     }>;
     /** Task status counts */
-    tasks: StructType<{
-        total: IntegerType;
-        upToDate: IntegerType;
-        ready: IntegerType;
-        waiting: IntegerType;
-        inProgress: IntegerType;
-        failed: IntegerType;
-        error: IntegerType;
-        staleRunning: IntegerType;
+    readonly tasks: StructType<{
+        readonly total: IntegerType;
+        readonly upToDate: IntegerType;
+        readonly ready: IntegerType;
+        readonly waiting: IntegerType;
+        readonly inProgress: IntegerType;
+        readonly failed: IntegerType;
+        readonly error: IntegerType;
+        readonly staleRunning: IntegerType;
     }>;
 }>;
 /**
@@ -543,179 +605,389 @@ export declare const WorkspaceStatusSummaryType: StructType<{
  * @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>;
+    readonly workspace: StringType;
+    readonly lock: OptionType<StructType<{
+        readonly pid: IntegerType;
+        readonly acquiredAt: StringType;
+        readonly bootId: OptionType<StringType>;
+        readonly 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>;
+    readonly datasets: ArrayType<StructType<{
+        readonly path: StringType;
+        readonly status: VariantType<{
+            readonly unset: NullType;
+            readonly stale: NullType;
+            readonly 'up-to-date': NullType;
+        }>;
+        readonly hash: OptionType<StringType>;
+        readonly isTaskOutput: BooleanType;
+        readonly producedBy: OptionType<StringType>;
     }>>;
-    tasks: ArrayType<StructType<{
-        name: StringType;
-        hash: StringType;
-        status: VariantType<{
-            'up-to-date': StructType<{
-                cached: BooleanType;
+    readonly tasks: ArrayType<StructType<{
+        readonly name: StringType;
+        readonly hash: StringType;
+        readonly status: VariantType<{
+            readonly 'up-to-date': StructType<{
+                readonly cached: BooleanType;
             }>;
-            ready: NullType;
-            waiting: StructType<{
-                reason: StringType;
+            readonly ready: NullType;
+            readonly waiting: StructType<{
+                readonly reason: StringType;
             }>;
-            'in-progress': StructType<{
+            readonly 'in-progress': StructType<{
                 /** Process ID of the running task */
-                pid: OptionType<IntegerType>;
+                readonly pid: OptionType<IntegerType>;
                 /** ISO timestamp when execution started */
-                startedAt: OptionType<StringType>;
+                readonly startedAt: OptionType<StringType>;
             }>;
-            failed: StructType<{
+            readonly failed: StructType<{
                 /** Process exit code */
-                exitCode: IntegerType;
+                readonly exitCode: IntegerType;
                 /** ISO timestamp when task completed */
-                completedAt: OptionType<StringType>;
+                readonly completedAt: OptionType<StringType>;
             }>;
-            error: StructType<{
+            readonly error: StructType<{
                 /** Error message */
-                message: StringType;
+                readonly message: StringType;
                 /** ISO timestamp when error occurred */
-                completedAt: OptionType<StringType>;
+                readonly completedAt: OptionType<StringType>;
             }>;
-            'stale-running': StructType<{
+            readonly 'stale-running': StructType<{
                 /** Last known process ID */
-                pid: OptionType<IntegerType>;
+                readonly pid: OptionType<IntegerType>;
                 /** ISO timestamp when execution started */
-                startedAt: OptionType<StringType>;
+                readonly startedAt: OptionType<StringType>;
             }>;
         }>;
-        inputs: ArrayType<StringType>;
-        output: StringType;
-        dependsOn: ArrayType<StringType>;
+        readonly inputs: ArrayType<StringType>;
+        readonly output: StringType;
+        readonly dependsOn: ArrayType<StringType>;
     }>>;
-    summary: StructType<{
+    readonly summary: StructType<{
         /** Dataset status counts */
-        datasets: StructType<{
-            total: IntegerType;
-            unset: IntegerType;
-            stale: IntegerType;
-            upToDate: IntegerType;
+        readonly datasets: StructType<{
+            readonly total: IntegerType;
+            readonly unset: IntegerType;
+            readonly stale: IntegerType;
+            readonly upToDate: IntegerType;
         }>;
         /** Task status counts */
-        tasks: StructType<{
-            total: IntegerType;
-            upToDate: IntegerType;
-            ready: IntegerType;
-            waiting: IntegerType;
-            inProgress: IntegerType;
-            failed: IntegerType;
-            error: IntegerType;
-            staleRunning: IntegerType;
+        readonly tasks: StructType<{
+            readonly total: IntegerType;
+            readonly upToDate: IntegerType;
+            readonly ready: IntegerType;
+            readonly waiting: IntegerType;
+            readonly inProgress: IntegerType;
+            readonly failed: IntegerType;
+            readonly error: IntegerType;
+            readonly staleRunning: IntegerType;
         }>;
     }>;
 }>;
 export declare const TaskListItemType: StructType<{
-    name: StringType;
-    hash: StringType;
+    readonly name: StringType;
+    readonly hash: StringType;
 }>;
 export declare const TaskInfoType: StructType<{
-    name: StringType;
-    hash: StringType;
+    readonly name: StringType;
+    readonly hash: StringType;
 }>;
 export declare const TaskDetailsType: StructType<{
-    name: StringType;
-    hash: StringType;
-    commandIr: StringType;
-    inputs: ArrayType<ArrayType<VariantType<{
-        field: StringType;
+    readonly name: StringType;
+    readonly hash: StringType;
+    readonly commandIr: StringType;
+    readonly inputs: ArrayType<ArrayType<VariantType<{
+        readonly field: StringType;
     }>>>;
-    output: ArrayType<VariantType<{
-        field: StringType;
+    readonly output: ArrayType<VariantType<{
+        readonly field: StringType;
     }>>;
 }>;
 export declare const DataflowRequestType: StructType<{
-    concurrency: OptionType<IntegerType>;
-    force: BooleanType;
-    filter: OptionType<StringType>;
+    readonly concurrency: OptionType<IntegerType>;
+    readonly force: BooleanType;
+    readonly filter: OptionType<StringType>;
 }>;
 export declare const StartRequestType: StructType<{
-    concurrency: OptionType<IntegerType>;
-    force: BooleanType;
-    filter: OptionType<StringType>;
+    readonly concurrency: OptionType<IntegerType>;
+    readonly force: BooleanType;
+    readonly filter: OptionType<StringType>;
 }>;
 export declare const GraphTaskType: StructType<{
-    name: StringType;
-    hash: StringType;
-    inputs: ArrayType<StringType>;
-    output: StringType;
-    dependsOn: ArrayType<StringType>;
+    readonly name: StringType;
+    readonly hash: StringType;
+    readonly inputs: ArrayType<StringType>;
+    readonly output: StringType;
+    readonly dependsOn: ArrayType<StringType>;
 }>;
 export declare const DataflowGraphType: StructType<{
-    tasks: ArrayType<StructType<{
-        name: StringType;
-        hash: StringType;
-        inputs: ArrayType<StringType>;
-        output: StringType;
-        dependsOn: ArrayType<StringType>;
+    readonly tasks: ArrayType<StructType<{
+        readonly name: StringType;
+        readonly hash: StringType;
+        readonly inputs: ArrayType<StringType>;
+        readonly output: StringType;
+        readonly dependsOn: ArrayType<StringType>;
     }>>;
 }>;
 export declare const LogChunkType: StructType<{
-    data: StringType;
-    offset: IntegerType;
-    size: IntegerType;
-    totalSize: IntegerType;
-    complete: BooleanType;
+    readonly data: StringType;
+    readonly offset: IntegerType;
+    readonly size: IntegerType;
+    readonly totalSize: IntegerType;
+    readonly complete: BooleanType;
 }>;
 export declare const TaskExecutionResultType: StructType<{
-    name: StringType;
-    cached: BooleanType;
-    state: VariantType<{
-        success: NullType;
-        failed: StructType<{
-            exitCode: IntegerType;
+    readonly name: StringType;
+    readonly cached: BooleanType;
+    readonly state: VariantType<{
+        readonly success: NullType;
+        readonly failed: StructType<{
+            readonly exitCode: IntegerType;
         }>;
-        error: StructType<{
-            message: StringType;
+        readonly error: StructType<{
+            readonly message: StringType;
         }>;
-        skipped: NullType;
+        readonly skipped: NullType;
     }>;
-    duration: FloatType;
+    readonly 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;
+    readonly success: BooleanType;
+    readonly executed: IntegerType;
+    readonly cached: IntegerType;
+    readonly failed: IntegerType;
+    readonly skipped: IntegerType;
+    readonly tasks: ArrayType<StructType<{
+        readonly name: StringType;
+        readonly cached: BooleanType;
+        readonly state: VariantType<{
+            readonly success: NullType;
+            readonly failed: StructType<{
+                readonly exitCode: IntegerType;
             }>;
-            error: StructType<{
-                message: StringType;
+            readonly error: StructType<{
+                readonly message: StringType;
             }>;
-            skipped: NullType;
+            readonly skipped: NullType;
         }>;
-        duration: FloatType;
+        readonly duration: FloatType;
     }>>;
-    duration: FloatType;
+    readonly duration: FloatType;
+}>;
+/**
+ * Dataflow event types.
+ *
+ * - `start`: Task started executing
+ * - `complete`: Task executed and succeeded
+ * - `cached`: Task result retrieved from cache (no execution)
+ * - `failed`: Task exited with non-zero code
+ * - `error`: Internal error during task execution
+ * - `input_unavailable`: Task couldn't run because inputs not available
+ */
+export declare const DataflowEventType: VariantType<{
+    readonly start: StructType<{
+        readonly task: StringType;
+        readonly timestamp: StringType;
+    }>;
+    readonly complete: StructType<{
+        readonly task: StringType;
+        readonly timestamp: StringType;
+        readonly duration: FloatType;
+    }>;
+    readonly cached: StructType<{
+        readonly task: StringType;
+        readonly timestamp: StringType;
+    }>;
+    readonly failed: StructType<{
+        readonly task: StringType;
+        readonly timestamp: StringType;
+        readonly duration: FloatType;
+        readonly exitCode: IntegerType;
+    }>;
+    readonly error: StructType<{
+        readonly task: StringType;
+        readonly timestamp: StringType;
+        readonly message: StringType;
+    }>;
+    readonly input_unavailable: StructType<{
+        readonly task: StringType;
+        readonly timestamp: StringType;
+        readonly reason: StringType;
+    }>;
+}>;
+/**
+ * Execution status variant.
+ *
+ * - `running`: Execution is in progress
+ * - `completed`: Execution finished successfully
+ * - `failed`: Execution finished with failures
+ * - `aborted`: Execution was cancelled
+ */
+export declare const ExecutionStatusType: VariantType<{
+    readonly running: NullType;
+    readonly completed: NullType;
+    readonly failed: NullType;
+    readonly aborted: NullType;
+}>;
+/**
+ * Summary of dataflow execution results.
+ */
+export declare const DataflowExecutionSummaryType: StructType<{
+    readonly executed: IntegerType;
+    readonly cached: IntegerType;
+    readonly failed: IntegerType;
+    readonly skipped: IntegerType;
+    readonly duration: FloatType;
+}>;
+/**
+ * State of a dataflow execution (for polling).
+ *
+ * @property status - Current execution status
+ * @property startedAt - ISO timestamp when execution started
+ * @property completedAt - ISO timestamp when execution finished (if done)
+ * @property summary - Execution summary (available when complete)
+ * @property events - Task events (may be paginated via offset/limit)
+ * @property totalEvents - Total number of events (for pagination)
+ */
+export declare const DataflowExecutionStateType: StructType<{
+    readonly status: VariantType<{
+        readonly running: NullType;
+        readonly completed: NullType;
+        readonly failed: NullType;
+        readonly aborted: NullType;
+    }>;
+    readonly startedAt: StringType;
+    readonly completedAt: OptionType<StringType>;
+    readonly summary: OptionType<StructType<{
+        readonly executed: IntegerType;
+        readonly cached: IntegerType;
+        readonly failed: IntegerType;
+        readonly skipped: IntegerType;
+        readonly duration: FloatType;
+    }>>;
+    readonly events: ArrayType<VariantType<{
+        readonly start: StructType<{
+            readonly task: StringType;
+            readonly timestamp: StringType;
+        }>;
+        readonly complete: StructType<{
+            readonly task: StringType;
+            readonly timestamp: StringType;
+            readonly duration: FloatType;
+        }>;
+        readonly cached: StructType<{
+            readonly task: StringType;
+            readonly timestamp: StringType;
+        }>;
+        readonly failed: StructType<{
+            readonly task: StringType;
+            readonly timestamp: StringType;
+            readonly duration: FloatType;
+            readonly exitCode: IntegerType;
+        }>;
+        readonly error: StructType<{
+            readonly task: StringType;
+            readonly timestamp: StringType;
+            readonly message: StringType;
+        }>;
+        readonly input_unavailable: StructType<{
+            readonly task: StringType;
+            readonly timestamp: StringType;
+            readonly reason: StringType;
+        }>;
+    }>>;
+    readonly totalEvents: IntegerType;
+}>;
+/**
+ * Execution status for history listing.
+ */
+export declare const ExecutionHistoryStatusType: VariantType<{
+    readonly running: NullType;
+    readonly success: NullType;
+    readonly failed: NullType;
+    readonly error: NullType;
+}>;
+/**
+ * A single execution in task history.
+ *
+ * @property inputsHash - Hash of concatenated inputs (execution identifier)
+ * @property inputHashes - Individual input object hashes
+ * @property status - Execution outcome
+ * @property startedAt - ISO timestamp when execution started
+ * @property completedAt - ISO timestamp when execution finished (if done)
+ * @property duration - Execution duration in milliseconds (if done)
+ * @property exitCode - Process exit code (if failed)
+ */
+export declare const ExecutionListItemType: StructType<{
+    readonly inputsHash: StringType;
+    readonly inputHashes: ArrayType<StringType>;
+    readonly status: VariantType<{
+        readonly running: NullType;
+        readonly success: NullType;
+        readonly failed: NullType;
+        readonly error: NullType;
+    }>;
+    readonly startedAt: StringType;
+    readonly completedAt: OptionType<StringType>;
+    readonly duration: OptionType<IntegerType>;
+    readonly exitCode: OptionType<IntegerType>;
+}>;
+/**
+ * A dataset in the flat list response.
+ *
+ * @property path - Full path to dataset (e.g., ".inputs.a.x")
+ * @property type - East type of the dataset (mandatory)
+ * @property hash - Object hash of the value (None if unassigned)
+ * @property size - Size in bytes (None if unassigned)
+ */
+export declare const DatasetListItemType: StructType<{
+    readonly path: StringType;
+    readonly type: import("@elaraai/east").RecursiveType<VariantType<{
+        readonly Never: NullType;
+        readonly Null: NullType;
+        readonly Boolean: NullType;
+        readonly Integer: NullType;
+        readonly Float: NullType;
+        readonly String: NullType;
+        readonly DateTime: NullType;
+        readonly Blob: NullType;
+        readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Dict: StructType<{
+            readonly key: import("@elaraai/east").RecursiveTypeMarker;
+            readonly value: import("@elaraai/east").RecursiveTypeMarker;
+        }>;
+        readonly Struct: ArrayType<StructType<{
+            readonly name: StringType;
+            readonly type: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        readonly Variant: ArrayType<StructType<{
+            readonly name: StringType;
+            readonly type: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        readonly Recursive: IntegerType;
+        readonly Function: StructType<{
+            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+        }>;
+        readonly AsyncFunction: StructType<{
+            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+        }>;
+        readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+    }>>;
+    readonly hash: OptionType<StringType>;
+    readonly size: OptionType<IntegerType>;
 }>;
 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 AsyncOperationStatus = ValueTypeOf<typeof AsyncOperationStatusType>;
+export type GcStartResult = ValueTypeOf<typeof GcStartResultType>;
+export type GcStatusResult = ValueTypeOf<typeof GcStatusResultType>;
 export type PackageListItem = ValueTypeOf<typeof PackageListItemType>;
 export type PackageImportResult = ValueTypeOf<typeof PackageImportResultType>;
 export type PackageInfo = ValueTypeOf<typeof PackageInfoType>;
@@ -737,574 +1009,778 @@ 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 type DataflowEvent = ValueTypeOf<typeof DataflowEventType>;
+export type ExecutionStatus = ValueTypeOf<typeof ExecutionStatusType>;
+export type DataflowExecutionSummary = ValueTypeOf<typeof DataflowExecutionSummaryType>;
+export type DataflowExecutionState = ValueTypeOf<typeof DataflowExecutionStateType>;
+export type ExecutionHistoryStatus = ValueTypeOf<typeof ExecutionHistoryStatusType>;
+export type ExecutionListItem = ValueTypeOf<typeof ExecutionListItemType>;
+export type DatasetListItem = ValueTypeOf<typeof DatasetListItemType>;
 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>;
+        readonly repository_not_found: StructType<{
+            readonly repo: StringType;
+        }>;
+        readonly workspace_not_found: StructType<{
+            readonly workspace: StringType;
+        }>;
+        readonly workspace_not_deployed: StructType<{
+            readonly workspace: StringType;
+        }>;
+        readonly workspace_exists: StructType<{
+            readonly workspace: StringType;
+        }>;
+        readonly workspace_locked: StructType<{
+            readonly workspace: StringType;
+            readonly holder: VariantType<{
+                readonly unknown: NullType;
+                readonly known: StructType<{
+                    readonly pid: IntegerType;
+                    readonly acquiredAt: StringType;
+                    readonly bootId: OptionType<StringType>;
+                    readonly command: OptionType<StringType>;
                 }>;
             }>;
         }>;
-        package_not_found: StructType<{
-            packageName: StringType;
-            version: OptionType<StringType>;
+        readonly package_not_found: StructType<{
+            readonly packageName: StringType;
+            readonly version: OptionType<StringType>;
         }>;
-        package_exists: StructType<{
-            packageName: StringType;
-            version: StringType;
+        readonly package_exists: StructType<{
+            readonly packageName: StringType;
+            readonly version: StringType;
         }>;
-        package_invalid: StructType<{
-            reason: StringType;
+        readonly package_invalid: StructType<{
+            readonly reason: StringType;
         }>;
-        dataset_not_found: StructType<{
-            workspace: StringType;
-            path: StringType;
+        readonly dataset_not_found: StructType<{
+            readonly workspace: StringType;
+            readonly path: StringType;
         }>;
-        task_not_found: StructType<{
-            task: StringType;
+        readonly task_not_found: StructType<{
+            readonly task: StringType;
         }>;
-        object_not_found: StructType<{
-            hash: StringType;
+        readonly execution_not_found: StructType<{
+            readonly task: StringType;
         }>;
-        dataflow_error: StructType<{
-            message: StringType;
+        readonly object_not_found: StructType<{
+            readonly hash: StringType;
         }>;
-        dataflow_aborted: NullType;
-        permission_denied: StructType<{
-            path: StringType;
+        readonly dataflow_error: StructType<{
+            readonly message: StringType;
         }>;
-        internal: StructType<{
-            message: StringType;
+        readonly dataflow_aborted: NullType;
+        readonly permission_denied: StructType<{
+            readonly path: StringType;
         }>;
+        readonly internal: StructType<{
+            readonly message: StringType;
+        }>;
+    }>;
+    readonly RepositoryNotFoundErrorType: StructType<{
+        readonly repo: StringType;
     }>;
     readonly WorkspaceNotFoundErrorType: StructType<{
-        workspace: StringType;
+        readonly workspace: StringType;
     }>;
     readonly WorkspaceNotDeployedErrorType: StructType<{
-        workspace: StringType;
+        readonly workspace: StringType;
     }>;
     readonly WorkspaceExistsErrorType: StructType<{
-        workspace: StringType;
+        readonly workspace: StringType;
     }>;
     readonly WorkspaceLockedErrorType: StructType<{
-        workspace: StringType;
-        holder: VariantType<{
-            unknown: NullType;
-            known: StructType<{
-                pid: IntegerType;
-                acquiredAt: StringType;
-                bootId: OptionType<StringType>;
-                command: OptionType<StringType>;
+        readonly workspace: StringType;
+        readonly holder: VariantType<{
+            readonly unknown: NullType;
+            readonly known: StructType<{
+                readonly pid: IntegerType;
+                readonly acquiredAt: StringType;
+                readonly bootId: OptionType<StringType>;
+                readonly command: OptionType<StringType>;
             }>;
         }>;
     }>;
     readonly LockHolderType: StructType<{
-        pid: IntegerType;
-        acquiredAt: StringType;
-        bootId: OptionType<StringType>;
-        command: OptionType<StringType>;
+        readonly pid: IntegerType;
+        readonly acquiredAt: StringType;
+        readonly bootId: OptionType<StringType>;
+        readonly command: OptionType<StringType>;
     }>;
     readonly PackageNotFoundErrorType: StructType<{
-        packageName: StringType;
-        version: OptionType<StringType>;
+        readonly packageName: StringType;
+        readonly version: OptionType<StringType>;
     }>;
     readonly PackageExistsErrorType: StructType<{
-        packageName: StringType;
-        version: StringType;
+        readonly packageName: StringType;
+        readonly version: StringType;
     }>;
     readonly PackageInvalidErrorType: StructType<{
-        reason: StringType;
+        readonly reason: StringType;
     }>;
     readonly DatasetNotFoundErrorType: StructType<{
-        workspace: StringType;
-        path: StringType;
+        readonly workspace: StringType;
+        readonly path: StringType;
     }>;
     readonly TaskNotFoundErrorType: StructType<{
-        task: StringType;
+        readonly task: StringType;
+    }>;
+    readonly ExecutionNotFoundErrorType: StructType<{
+        readonly task: StringType;
     }>;
     readonly ObjectNotFoundErrorType: StructType<{
-        hash: StringType;
+        readonly hash: StringType;
     }>;
     readonly DataflowErrorType: StructType<{
-        message: StringType;
+        readonly message: StringType;
     }>;
     readonly PermissionDeniedErrorType: StructType<{
-        path: StringType;
+        readonly path: StringType;
     }>;
     readonly InternalErrorType: StructType<{
-        message: StringType;
+        readonly message: StringType;
     }>;
     readonly ResponseType: <T extends EastType>(successType: T) => VariantType<{
-        success: T;
-        error: VariantType<{
-            workspace_not_found: StructType<{
-                workspace: StringType;
+        readonly success: T;
+        readonly error: VariantType<{
+            readonly repository_not_found: StructType<{
+                readonly repo: StringType;
             }>;
-            workspace_not_deployed: StructType<{
-                workspace: StringType;
+            readonly workspace_not_found: StructType<{
+                readonly workspace: StringType;
             }>;
-            workspace_exists: StructType<{
-                workspace: StringType;
+            readonly workspace_not_deployed: StructType<{
+                readonly workspace: StringType;
             }>;
-            workspace_locked: StructType<{
-                workspace: StringType;
-                holder: VariantType<{
-                    unknown: NullType;
-                    known: StructType<{
-                        pid: IntegerType;
-                        acquiredAt: StringType;
-                        bootId: OptionType<StringType>;
-                        command: OptionType<StringType>;
+            readonly workspace_exists: StructType<{
+                readonly workspace: StringType;
+            }>;
+            readonly workspace_locked: StructType<{
+                readonly workspace: StringType;
+                readonly holder: VariantType<{
+                    readonly unknown: NullType;
+                    readonly known: StructType<{
+                        readonly pid: IntegerType;
+                        readonly acquiredAt: StringType;
+                        readonly bootId: OptionType<StringType>;
+                        readonly command: OptionType<StringType>;
                     }>;
                 }>;
             }>;
-            package_not_found: StructType<{
-                packageName: StringType;
-                version: OptionType<StringType>;
+            readonly package_not_found: StructType<{
+                readonly packageName: StringType;
+                readonly version: OptionType<StringType>;
+            }>;
+            readonly package_exists: StructType<{
+                readonly packageName: StringType;
+                readonly version: StringType;
             }>;
-            package_exists: StructType<{
-                packageName: StringType;
-                version: StringType;
+            readonly package_invalid: StructType<{
+                readonly reason: StringType;
             }>;
-            package_invalid: StructType<{
-                reason: StringType;
+            readonly dataset_not_found: StructType<{
+                readonly workspace: StringType;
+                readonly path: StringType;
             }>;
-            dataset_not_found: StructType<{
-                workspace: StringType;
-                path: StringType;
+            readonly task_not_found: StructType<{
+                readonly task: StringType;
             }>;
-            task_not_found: StructType<{
-                task: StringType;
+            readonly execution_not_found: StructType<{
+                readonly task: StringType;
             }>;
-            object_not_found: StructType<{
-                hash: StringType;
+            readonly object_not_found: StructType<{
+                readonly hash: StringType;
             }>;
-            dataflow_error: StructType<{
-                message: StringType;
+            readonly dataflow_error: StructType<{
+                readonly message: StringType;
             }>;
-            dataflow_aborted: NullType;
-            permission_denied: StructType<{
-                path: StringType;
+            readonly dataflow_aborted: NullType;
+            readonly permission_denied: StructType<{
+                readonly path: StringType;
             }>;
-            internal: StructType<{
-                message: StringType;
+            readonly internal: StructType<{
+                readonly message: StringType;
             }>;
         }>;
     }>;
     readonly RepositoryStatusType: StructType<{
-        path: StringType;
-        objectCount: IntegerType;
-        packageCount: IntegerType;
-        workspaceCount: IntegerType;
+        readonly path: StringType;
+        readonly objectCount: IntegerType;
+        readonly packageCount: IntegerType;
+        readonly workspaceCount: IntegerType;
     }>;
     readonly GcRequestType: StructType<{
-        dryRun: BooleanType;
-        minAge: OptionType<IntegerType>;
+        readonly dryRun: BooleanType;
+        readonly minAge: OptionType<IntegerType>;
     }>;
     readonly GcResultType: StructType<{
-        deletedObjects: IntegerType;
-        deletedPartials: IntegerType;
-        retainedObjects: IntegerType;
-        skippedYoung: IntegerType;
-        bytesFreed: IntegerType;
+        readonly deletedObjects: IntegerType;
+        readonly deletedPartials: IntegerType;
+        readonly retainedObjects: IntegerType;
+        readonly skippedYoung: IntegerType;
+        readonly bytesFreed: IntegerType;
+    }>;
+    readonly AsyncOperationStatusType: VariantType<{
+        readonly running: NullType;
+        readonly succeeded: NullType;
+        readonly failed: NullType;
+    }>;
+    readonly GcStartResultType: StructType<{
+        readonly executionId: StringType;
+    }>;
+    readonly GcStatusResultType: StructType<{
+        readonly status: VariantType<{
+            readonly running: NullType;
+            readonly succeeded: NullType;
+            readonly failed: NullType;
+        }>;
+        readonly stats: OptionType<StructType<{
+            readonly deletedObjects: IntegerType;
+            readonly deletedPartials: IntegerType;
+            readonly retainedObjects: IntegerType;
+            readonly skippedYoung: IntegerType;
+            readonly bytesFreed: IntegerType;
+        }>>;
+        readonly error: OptionType<StringType>;
     }>;
     readonly PackageListItemType: StructType<{
-        name: StringType;
-        version: StringType;
+        readonly name: StringType;
+        readonly version: StringType;
     }>;
     readonly PackageImportResultType: StructType<{
-        name: StringType;
-        version: StringType;
-        packageHash: StringType;
-        objectCount: IntegerType;
+        readonly name: StringType;
+        readonly version: StringType;
+        readonly packageHash: StringType;
+        readonly objectCount: IntegerType;
     }>;
     readonly PackageInfoType: StructType<{
-        name: StringType;
-        version: StringType;
-        hash: StringType;
+        readonly name: StringType;
+        readonly version: StringType;
+        readonly 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;
+        readonly name: StringType;
+        readonly version: StringType;
+        readonly hash: StringType;
+        readonly tasks: ArrayType<StringType>;
+        readonly dataStructure: import("@elaraai/east").RecursiveType<VariantType<{
+            readonly value: import("@elaraai/east").RecursiveType<VariantType<{
+                readonly Never: import("@elaraai/east").NullType;
+                readonly Null: import("@elaraai/east").NullType;
+                readonly Boolean: import("@elaraai/east").NullType;
+                readonly Integer: import("@elaraai/east").NullType;
+                readonly Float: import("@elaraai/east").NullType;
+                readonly String: import("@elaraai/east").NullType;
+                readonly DateTime: import("@elaraai/east").NullType;
+                readonly Blob: import("@elaraai/east").NullType;
+                readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Dict: import("@elaraai/east").StructType<{
+                    readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly value: import("@elaraai/east").RecursiveTypeMarker;
                 }>;
-                Struct: ArrayType<import("@elaraai/east").StructType<{
-                    name: StringType;
-                    type: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Struct: ArrayType<import("@elaraai/east").StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
                 }>>;
-                Variant: ArrayType<import("@elaraai/east").StructType<{
-                    name: StringType;
-                    type: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Variant: ArrayType<import("@elaraai/east").StructType<{
+                    readonly name: StringType;
+                    readonly 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;
+                readonly Recursive: import("@elaraai/east").IntegerType;
+                readonly Function: import("@elaraai/east").StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
                 }>;
-                AsyncFunction: import("@elaraai/east").StructType<{
-                    inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
-                    output: import("@elaraai/east").RecursiveTypeMarker;
+                readonly AsyncFunction: import("@elaraai/east").StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
                 }>;
+                readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
             }>>;
-            struct: import("@elaraai/east").DictType<StringType, import("@elaraai/east").RecursiveTypeMarker>;
+            readonly struct: import("@elaraai/east").DictType<StringType, import("@elaraai/east").RecursiveTypeMarker>;
         }>>;
     }>;
     readonly WorkspaceCreateRequestType: StructType<{
-        name: StringType;
+        readonly name: StringType;
     }>;
     readonly WorkspaceInfoType: StructType<{
-        name: StringType;
-        deployed: BooleanType;
-        packageName: OptionType<StringType>;
-        packageVersion: OptionType<StringType>;
+        readonly name: StringType;
+        readonly deployed: BooleanType;
+        readonly packageName: OptionType<StringType>;
+        readonly packageVersion: OptionType<StringType>;
     }>;
     readonly WorkspaceDeployRequestType: StructType<{
-        packageName: StringType;
-        packageVersion: StringType;
+        readonly packageName: StringType;
+        readonly packageVersion: StringType;
     }>;
     readonly DeployRequestType: StructType<{
-        packageRef: StringType;
+        readonly packageRef: StringType;
     }>;
     readonly DatasetStatusType: VariantType<{
-        unset: NullType;
-        stale: NullType;
-        'up-to-date': NullType;
+        readonly unset: NullType;
+        readonly stale: NullType;
+        readonly 'up-to-date': NullType;
     }>;
     readonly TaskStatusType: VariantType<{
-        'up-to-date': StructType<{
-            cached: BooleanType;
+        readonly 'up-to-date': StructType<{
+            readonly cached: BooleanType;
         }>;
-        ready: NullType;
-        waiting: StructType<{
-            reason: StringType;
+        readonly ready: NullType;
+        readonly waiting: StructType<{
+            readonly reason: StringType;
         }>;
-        'in-progress': StructType<{
+        readonly 'in-progress': StructType<{
             /** Process ID of the running task */
-            pid: OptionType<IntegerType>;
+            readonly pid: OptionType<IntegerType>;
             /** ISO timestamp when execution started */
-            startedAt: OptionType<StringType>;
+            readonly startedAt: OptionType<StringType>;
         }>;
-        failed: StructType<{
+        readonly failed: StructType<{
             /** Process exit code */
-            exitCode: IntegerType;
+            readonly exitCode: IntegerType;
             /** ISO timestamp when task completed */
-            completedAt: OptionType<StringType>;
+            readonly completedAt: OptionType<StringType>;
         }>;
-        error: StructType<{
+        readonly error: StructType<{
             /** Error message */
-            message: StringType;
+            readonly message: StringType;
             /** ISO timestamp when error occurred */
-            completedAt: OptionType<StringType>;
+            readonly completedAt: OptionType<StringType>;
         }>;
-        'stale-running': StructType<{
+        readonly 'stale-running': StructType<{
             /** Last known process ID */
-            pid: OptionType<IntegerType>;
+            readonly pid: OptionType<IntegerType>;
             /** ISO timestamp when execution started */
-            startedAt: OptionType<StringType>;
+            readonly startedAt: OptionType<StringType>;
         }>;
     }>;
     readonly TaskStatusUpToDateType: StructType<{
-        cached: BooleanType;
+        readonly cached: BooleanType;
     }>;
     readonly TaskStatusWaitingType: StructType<{
-        reason: StringType;
+        readonly reason: StringType;
     }>;
     readonly TaskStatusInProgressType: StructType<{
         /** Process ID of the running task */
-        pid: OptionType<IntegerType>;
+        readonly pid: OptionType<IntegerType>;
         /** ISO timestamp when execution started */
-        startedAt: OptionType<StringType>;
+        readonly startedAt: OptionType<StringType>;
     }>;
     readonly TaskStatusFailedType: StructType<{
         /** Process exit code */
-        exitCode: IntegerType;
+        readonly exitCode: IntegerType;
         /** ISO timestamp when task completed */
-        completedAt: OptionType<StringType>;
+        readonly completedAt: OptionType<StringType>;
     }>;
     readonly TaskStatusErrorType: StructType<{
         /** Error message */
-        message: StringType;
+        readonly message: StringType;
         /** ISO timestamp when error occurred */
-        completedAt: OptionType<StringType>;
+        readonly completedAt: OptionType<StringType>;
     }>;
     readonly TaskStatusStaleRunningType: StructType<{
         /** Last known process ID */
-        pid: OptionType<IntegerType>;
+        readonly pid: OptionType<IntegerType>;
         /** ISO timestamp when execution started */
-        startedAt: OptionType<StringType>;
+        readonly startedAt: OptionType<StringType>;
     }>;
     readonly DatasetStatusInfoType: StructType<{
-        path: StringType;
-        status: VariantType<{
-            unset: NullType;
-            stale: NullType;
-            'up-to-date': NullType;
+        readonly path: StringType;
+        readonly status: VariantType<{
+            readonly unset: NullType;
+            readonly stale: NullType;
+            readonly 'up-to-date': NullType;
         }>;
-        hash: OptionType<StringType>;
-        isTaskOutput: BooleanType;
-        producedBy: OptionType<StringType>;
+        readonly hash: OptionType<StringType>;
+        readonly isTaskOutput: BooleanType;
+        readonly producedBy: OptionType<StringType>;
     }>;
     readonly TaskStatusInfoType: StructType<{
-        name: StringType;
-        hash: StringType;
-        status: VariantType<{
-            'up-to-date': StructType<{
-                cached: BooleanType;
+        readonly name: StringType;
+        readonly hash: StringType;
+        readonly status: VariantType<{
+            readonly 'up-to-date': StructType<{
+                readonly cached: BooleanType;
             }>;
-            ready: NullType;
-            waiting: StructType<{
-                reason: StringType;
+            readonly ready: NullType;
+            readonly waiting: StructType<{
+                readonly reason: StringType;
             }>;
-            'in-progress': StructType<{
+            readonly 'in-progress': StructType<{
                 /** Process ID of the running task */
-                pid: OptionType<IntegerType>;
+                readonly pid: OptionType<IntegerType>;
                 /** ISO timestamp when execution started */
-                startedAt: OptionType<StringType>;
+                readonly startedAt: OptionType<StringType>;
             }>;
-            failed: StructType<{
+            readonly failed: StructType<{
                 /** Process exit code */
-                exitCode: IntegerType;
+                readonly exitCode: IntegerType;
                 /** ISO timestamp when task completed */
-                completedAt: OptionType<StringType>;
+                readonly completedAt: OptionType<StringType>;
             }>;
-            error: StructType<{
+            readonly error: StructType<{
                 /** Error message */
-                message: StringType;
+                readonly message: StringType;
                 /** ISO timestamp when error occurred */
-                completedAt: OptionType<StringType>;
+                readonly completedAt: OptionType<StringType>;
             }>;
-            'stale-running': StructType<{
+            readonly 'stale-running': StructType<{
                 /** Last known process ID */
-                pid: OptionType<IntegerType>;
+                readonly pid: OptionType<IntegerType>;
                 /** ISO timestamp when execution started */
-                startedAt: OptionType<StringType>;
+                readonly startedAt: OptionType<StringType>;
             }>;
         }>;
-        inputs: ArrayType<StringType>;
-        output: StringType;
-        dependsOn: ArrayType<StringType>;
+        readonly inputs: ArrayType<StringType>;
+        readonly output: StringType;
+        readonly dependsOn: ArrayType<StringType>;
     }>;
     readonly WorkspaceStatusSummaryType: StructType<{
         /** Dataset status counts */
-        datasets: StructType<{
-            total: IntegerType;
-            unset: IntegerType;
-            stale: IntegerType;
-            upToDate: IntegerType;
+        readonly datasets: StructType<{
+            readonly total: IntegerType;
+            readonly unset: IntegerType;
+            readonly stale: IntegerType;
+            readonly upToDate: IntegerType;
         }>;
         /** Task status counts */
-        tasks: StructType<{
-            total: IntegerType;
-            upToDate: IntegerType;
-            ready: IntegerType;
-            waiting: IntegerType;
-            inProgress: IntegerType;
-            failed: IntegerType;
-            error: IntegerType;
-            staleRunning: IntegerType;
+        readonly tasks: StructType<{
+            readonly total: IntegerType;
+            readonly upToDate: IntegerType;
+            readonly ready: IntegerType;
+            readonly waiting: IntegerType;
+            readonly inProgress: IntegerType;
+            readonly failed: IntegerType;
+            readonly error: IntegerType;
+            readonly staleRunning: IntegerType;
         }>;
     }>;
     readonly WorkspaceStatusResultType: StructType<{
-        workspace: StringType;
-        lock: OptionType<StructType<{
-            pid: IntegerType;
-            acquiredAt: StringType;
-            bootId: OptionType<StringType>;
-            command: OptionType<StringType>;
+        readonly workspace: StringType;
+        readonly lock: OptionType<StructType<{
+            readonly pid: IntegerType;
+            readonly acquiredAt: StringType;
+            readonly bootId: OptionType<StringType>;
+            readonly command: OptionType<StringType>;
         }>>;
-        datasets: ArrayType<StructType<{
-            path: StringType;
-            status: VariantType<{
-                unset: NullType;
-                stale: NullType;
-                'up-to-date': NullType;
+        readonly datasets: ArrayType<StructType<{
+            readonly path: StringType;
+            readonly status: VariantType<{
+                readonly unset: NullType;
+                readonly stale: NullType;
+                readonly 'up-to-date': NullType;
             }>;
-            hash: OptionType<StringType>;
-            isTaskOutput: BooleanType;
-            producedBy: OptionType<StringType>;
+            readonly hash: OptionType<StringType>;
+            readonly isTaskOutput: BooleanType;
+            readonly producedBy: OptionType<StringType>;
         }>>;
-        tasks: ArrayType<StructType<{
-            name: StringType;
-            hash: StringType;
-            status: VariantType<{
-                'up-to-date': StructType<{
-                    cached: BooleanType;
+        readonly tasks: ArrayType<StructType<{
+            readonly name: StringType;
+            readonly hash: StringType;
+            readonly status: VariantType<{
+                readonly 'up-to-date': StructType<{
+                    readonly cached: BooleanType;
                 }>;
-                ready: NullType;
-                waiting: StructType<{
-                    reason: StringType;
+                readonly ready: NullType;
+                readonly waiting: StructType<{
+                    readonly reason: StringType;
                 }>;
-                'in-progress': StructType<{
+                readonly 'in-progress': StructType<{
                     /** Process ID of the running task */
-                    pid: OptionType<IntegerType>;
+                    readonly pid: OptionType<IntegerType>;
                     /** ISO timestamp when execution started */
-                    startedAt: OptionType<StringType>;
+                    readonly startedAt: OptionType<StringType>;
                 }>;
-                failed: StructType<{
+                readonly failed: StructType<{
                     /** Process exit code */
-                    exitCode: IntegerType;
+                    readonly exitCode: IntegerType;
                     /** ISO timestamp when task completed */
-                    completedAt: OptionType<StringType>;
+                    readonly completedAt: OptionType<StringType>;
                 }>;
-                error: StructType<{
+                readonly error: StructType<{
                     /** Error message */
-                    message: StringType;
+                    readonly message: StringType;
                     /** ISO timestamp when error occurred */
-                    completedAt: OptionType<StringType>;
+                    readonly completedAt: OptionType<StringType>;
                 }>;
-                'stale-running': StructType<{
+                readonly 'stale-running': StructType<{
                     /** Last known process ID */
-                    pid: OptionType<IntegerType>;
+                    readonly pid: OptionType<IntegerType>;
                     /** ISO timestamp when execution started */
-                    startedAt: OptionType<StringType>;
+                    readonly startedAt: OptionType<StringType>;
                 }>;
             }>;
-            inputs: ArrayType<StringType>;
-            output: StringType;
-            dependsOn: ArrayType<StringType>;
+            readonly inputs: ArrayType<StringType>;
+            readonly output: StringType;
+            readonly dependsOn: ArrayType<StringType>;
         }>>;
-        summary: StructType<{
+        readonly summary: StructType<{
             /** Dataset status counts */
-            datasets: StructType<{
-                total: IntegerType;
-                unset: IntegerType;
-                stale: IntegerType;
-                upToDate: IntegerType;
+            readonly datasets: StructType<{
+                readonly total: IntegerType;
+                readonly unset: IntegerType;
+                readonly stale: IntegerType;
+                readonly upToDate: IntegerType;
             }>;
             /** Task status counts */
-            tasks: StructType<{
-                total: IntegerType;
-                upToDate: IntegerType;
-                ready: IntegerType;
-                waiting: IntegerType;
-                inProgress: IntegerType;
-                failed: IntegerType;
-                error: IntegerType;
-                staleRunning: IntegerType;
+            readonly tasks: StructType<{
+                readonly total: IntegerType;
+                readonly upToDate: IntegerType;
+                readonly ready: IntegerType;
+                readonly waiting: IntegerType;
+                readonly inProgress: IntegerType;
+                readonly failed: IntegerType;
+                readonly error: IntegerType;
+                readonly staleRunning: IntegerType;
             }>;
         }>;
     }>;
     readonly TaskListItemType: StructType<{
-        name: StringType;
-        hash: StringType;
+        readonly name: StringType;
+        readonly hash: StringType;
     }>;
     readonly TaskInfoType: StructType<{
-        name: StringType;
-        hash: StringType;
+        readonly name: StringType;
+        readonly hash: StringType;
     }>;
     readonly TaskDetailsType: StructType<{
-        name: StringType;
-        hash: StringType;
-        commandIr: StringType;
-        inputs: ArrayType<ArrayType<VariantType<{
-            field: StringType;
+        readonly name: StringType;
+        readonly hash: StringType;
+        readonly commandIr: StringType;
+        readonly inputs: ArrayType<ArrayType<VariantType<{
+            readonly field: StringType;
         }>>>;
-        output: ArrayType<VariantType<{
-            field: StringType;
+        readonly output: ArrayType<VariantType<{
+            readonly field: StringType;
         }>>;
     }>;
     readonly DataflowRequestType: StructType<{
-        concurrency: OptionType<IntegerType>;
-        force: BooleanType;
-        filter: OptionType<StringType>;
+        readonly concurrency: OptionType<IntegerType>;
+        readonly force: BooleanType;
+        readonly filter: OptionType<StringType>;
     }>;
     readonly StartRequestType: StructType<{
-        concurrency: OptionType<IntegerType>;
-        force: BooleanType;
-        filter: OptionType<StringType>;
+        readonly concurrency: OptionType<IntegerType>;
+        readonly force: BooleanType;
+        readonly filter: OptionType<StringType>;
     }>;
     readonly GraphTaskType: StructType<{
-        name: StringType;
-        hash: StringType;
-        inputs: ArrayType<StringType>;
-        output: StringType;
-        dependsOn: ArrayType<StringType>;
+        readonly name: StringType;
+        readonly hash: StringType;
+        readonly inputs: ArrayType<StringType>;
+        readonly output: StringType;
+        readonly dependsOn: ArrayType<StringType>;
     }>;
     readonly DataflowGraphType: StructType<{
-        tasks: ArrayType<StructType<{
-            name: StringType;
-            hash: StringType;
-            inputs: ArrayType<StringType>;
-            output: StringType;
-            dependsOn: ArrayType<StringType>;
+        readonly tasks: ArrayType<StructType<{
+            readonly name: StringType;
+            readonly hash: StringType;
+            readonly inputs: ArrayType<StringType>;
+            readonly output: StringType;
+            readonly dependsOn: ArrayType<StringType>;
         }>>;
     }>;
     readonly LogChunkType: StructType<{
-        data: StringType;
-        offset: IntegerType;
-        size: IntegerType;
-        totalSize: IntegerType;
-        complete: BooleanType;
+        readonly data: StringType;
+        readonly offset: IntegerType;
+        readonly size: IntegerType;
+        readonly totalSize: IntegerType;
+        readonly complete: BooleanType;
     }>;
     readonly TaskExecutionResultType: StructType<{
-        name: StringType;
-        cached: BooleanType;
-        state: VariantType<{
-            success: NullType;
-            failed: StructType<{
-                exitCode: IntegerType;
+        readonly name: StringType;
+        readonly cached: BooleanType;
+        readonly state: VariantType<{
+            readonly success: NullType;
+            readonly failed: StructType<{
+                readonly exitCode: IntegerType;
             }>;
-            error: StructType<{
-                message: StringType;
+            readonly error: StructType<{
+                readonly message: StringType;
             }>;
-            skipped: NullType;
+            readonly skipped: NullType;
         }>;
-        duration: FloatType;
+        readonly 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;
+        readonly success: BooleanType;
+        readonly executed: IntegerType;
+        readonly cached: IntegerType;
+        readonly failed: IntegerType;
+        readonly skipped: IntegerType;
+        readonly tasks: ArrayType<StructType<{
+            readonly name: StringType;
+            readonly cached: BooleanType;
+            readonly state: VariantType<{
+                readonly success: NullType;
+                readonly failed: StructType<{
+                    readonly exitCode: IntegerType;
                 }>;
-                error: StructType<{
-                    message: StringType;
+                readonly error: StructType<{
+                    readonly message: StringType;
                 }>;
-                skipped: NullType;
+                readonly skipped: NullType;
+            }>;
+            readonly duration: FloatType;
+        }>>;
+        readonly duration: FloatType;
+    }>;
+    readonly DataflowEventType: VariantType<{
+        readonly start: StructType<{
+            readonly task: StringType;
+            readonly timestamp: StringType;
+        }>;
+        readonly complete: StructType<{
+            readonly task: StringType;
+            readonly timestamp: StringType;
+            readonly duration: FloatType;
+        }>;
+        readonly cached: StructType<{
+            readonly task: StringType;
+            readonly timestamp: StringType;
+        }>;
+        readonly failed: StructType<{
+            readonly task: StringType;
+            readonly timestamp: StringType;
+            readonly duration: FloatType;
+            readonly exitCode: IntegerType;
+        }>;
+        readonly error: StructType<{
+            readonly task: StringType;
+            readonly timestamp: StringType;
+            readonly message: StringType;
+        }>;
+        readonly input_unavailable: StructType<{
+            readonly task: StringType;
+            readonly timestamp: StringType;
+            readonly reason: StringType;
+        }>;
+    }>;
+    readonly ExecutionStatusType: VariantType<{
+        readonly running: NullType;
+        readonly completed: NullType;
+        readonly failed: NullType;
+        readonly aborted: NullType;
+    }>;
+    readonly DataflowExecutionSummaryType: StructType<{
+        readonly executed: IntegerType;
+        readonly cached: IntegerType;
+        readonly failed: IntegerType;
+        readonly skipped: IntegerType;
+        readonly duration: FloatType;
+    }>;
+    readonly DataflowExecutionStateType: StructType<{
+        readonly status: VariantType<{
+            readonly running: NullType;
+            readonly completed: NullType;
+            readonly failed: NullType;
+            readonly aborted: NullType;
+        }>;
+        readonly startedAt: StringType;
+        readonly completedAt: OptionType<StringType>;
+        readonly summary: OptionType<StructType<{
+            readonly executed: IntegerType;
+            readonly cached: IntegerType;
+            readonly failed: IntegerType;
+            readonly skipped: IntegerType;
+            readonly duration: FloatType;
+        }>>;
+        readonly events: ArrayType<VariantType<{
+            readonly start: StructType<{
+                readonly task: StringType;
+                readonly timestamp: StringType;
+            }>;
+            readonly complete: StructType<{
+                readonly task: StringType;
+                readonly timestamp: StringType;
+                readonly duration: FloatType;
+            }>;
+            readonly cached: StructType<{
+                readonly task: StringType;
+                readonly timestamp: StringType;
+            }>;
+            readonly failed: StructType<{
+                readonly task: StringType;
+                readonly timestamp: StringType;
+                readonly duration: FloatType;
+                readonly exitCode: IntegerType;
+            }>;
+            readonly error: StructType<{
+                readonly task: StringType;
+                readonly timestamp: StringType;
+                readonly message: StringType;
+            }>;
+            readonly input_unavailable: StructType<{
+                readonly task: StringType;
+                readonly timestamp: StringType;
+                readonly reason: StringType;
+            }>;
+        }>>;
+        readonly totalEvents: IntegerType;
+    }>;
+    readonly ExecutionHistoryStatusType: VariantType<{
+        readonly running: NullType;
+        readonly success: NullType;
+        readonly failed: NullType;
+        readonly error: NullType;
+    }>;
+    readonly ExecutionListItemType: StructType<{
+        readonly inputsHash: StringType;
+        readonly inputHashes: ArrayType<StringType>;
+        readonly status: VariantType<{
+            readonly running: NullType;
+            readonly success: NullType;
+            readonly failed: NullType;
+            readonly error: NullType;
+        }>;
+        readonly startedAt: StringType;
+        readonly completedAt: OptionType<StringType>;
+        readonly duration: OptionType<IntegerType>;
+        readonly exitCode: OptionType<IntegerType>;
+    }>;
+    readonly DatasetListItemType: StructType<{
+        readonly path: StringType;
+        readonly type: import("@elaraai/east").RecursiveType<VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: IntegerType;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
             }>;
-            duration: FloatType;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
         }>>;
-        duration: FloatType;
+        readonly hash: OptionType<StringType>;
+        readonly size: OptionType<IntegerType>;
     }>;
 };
 //# sourceMappingURL=types.d.ts.map