@elaraai/e3-types 0.0.2-beta.46 → 0.0.2-beta.47

package/dist/src/api.d.ts

@@ -0,0 +1,1111 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * API wire types for e3.
+ *
+ * These East types define the request/response schemas used by the e3 REST API.
+ * They are shared between e3-api-client and e3-api-server.
+ *
+ * Types that also serve as domain types (PackageImportResultType, DataflowGraphType,
+ * DataflowGraphTaskType) are defined in their respective modules and re-exported here.
+ *
+ * Two types are prefixed with "Api" to avoid name conflicts with domain types
+ * that have the same name but different structure:
+ * - ApiExecutionStatusType (vs ExecutionStatusType in execution.ts — on-disk task status)
+ * - ApiDataflowExecutionStateType (vs DataflowExecutionStateType in dataflow.ts — persistent state)
+ */
+import { VariantType, StructType, ArrayType, OptionType, StringType, IntegerType, FloatType, BooleanType, NullType, type EastType, type ValueTypeOf } from '@elaraai/east';
+export declare const WorkspaceNotFoundErrorType: StructType<{
+    readonly workspace: StringType;
+}>;
+export declare const WorkspaceNotDeployedErrorType: StructType<{
+    readonly workspace: StringType;
+}>;
+export declare const WorkspaceExistsErrorType: StructType<{
+    readonly workspace: StringType;
+}>;
+export declare const LockHolderType: StructType<{
+    readonly pid: IntegerType;
+    readonly acquiredAt: StringType;
+    readonly bootId: OptionType<StringType>;
+    readonly command: OptionType<StringType>;
+}>;
+export declare const WorkspaceLockedErrorType: 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>;
+        }>;
+    }>;
+}>;
+export declare const PackageNotFoundErrorType: StructType<{
+    readonly packageName: StringType;
+    readonly version: OptionType<StringType>;
+}>;
+export declare const PackageExistsErrorType: StructType<{
+    readonly packageName: StringType;
+    readonly version: StringType;
+}>;
+export declare const PackageInvalidErrorType: StructType<{
+    readonly reason: StringType;
+}>;
+export declare const DatasetNotFoundErrorType: StructType<{
+    readonly workspace: StringType;
+    readonly path: StringType;
+}>;
+export declare const TaskNotFoundErrorType: StructType<{
+    readonly task: StringType;
+}>;
+export declare const ExecutionNotFoundErrorType: StructType<{
+    readonly task: StringType;
+}>;
+export declare const ObjectNotFoundErrorType: StructType<{
+    readonly hash: StringType;
+}>;
+export declare const DataflowErrorType: StructType<{
+    readonly message: StringType;
+}>;
+export declare const PermissionDeniedErrorType: StructType<{
+    readonly path: StringType;
+}>;
+export declare const InternalErrorType: StructType<{
+    readonly message: StringType;
+}>;
+export declare const RepositoryNotFoundErrorType: StructType<{
+    readonly repo: StringType;
+}>;
+export declare const ErrorType: 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>;
+            }>;
+        }>;
+    }>;
+    readonly package_not_found: StructType<{
+        readonly packageName: StringType;
+        readonly version: OptionType<StringType>;
+    }>;
+    readonly package_exists: StructType<{
+        readonly packageName: StringType;
+        readonly version: StringType;
+    }>;
+    readonly package_invalid: StructType<{
+        readonly reason: StringType;
+    }>;
+    readonly dataset_not_found: StructType<{
+        readonly workspace: StringType;
+        readonly path: StringType;
+    }>;
+    readonly task_not_found: StructType<{
+        readonly task: StringType;
+    }>;
+    readonly execution_not_found: StructType<{
+        readonly task: StringType;
+    }>;
+    readonly object_not_found: StructType<{
+        readonly hash: StringType;
+    }>;
+    readonly dataflow_error: StructType<{
+        readonly 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<{
+    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>;
+                }>;
+            }>;
+        }>;
+        readonly package_not_found: StructType<{
+            readonly packageName: StringType;
+            readonly version: OptionType<StringType>;
+        }>;
+        readonly package_exists: StructType<{
+            readonly packageName: StringType;
+            readonly version: StringType;
+        }>;
+        readonly package_invalid: StructType<{
+            readonly reason: StringType;
+        }>;
+        readonly dataset_not_found: StructType<{
+            readonly workspace: StringType;
+            readonly path: StringType;
+        }>;
+        readonly task_not_found: StructType<{
+            readonly task: StringType;
+        }>;
+        readonly execution_not_found: StructType<{
+            readonly task: StringType;
+        }>;
+        readonly object_not_found: StructType<{
+            readonly hash: StringType;
+        }>;
+        readonly dataflow_error: StructType<{
+            readonly 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 objectCount - Number of content-addressed objects stored
+ * @property packageCount - Number of imported packages
+ * @property workspaceCount - Number of workspaces
+ */
+export declare const RepositoryStatusType: StructType<{
+    readonly path: StringType;
+    readonly objectCount: IntegerType;
+    readonly packageCount: IntegerType;
+    readonly workspaceCount: IntegerType;
+}>;
+/**
+ * Garbage collection request options.
+ *
+ * @property dryRun - If true, report what would be deleted without deleting
+ * @property minAge - Minimum age in milliseconds for objects to be considered for deletion
+ */
+export declare const GcRequestType: StructType<{
+    readonly dryRun: BooleanType;
+    readonly minAge: OptionType<IntegerType>;
+}>;
+/**
+ * Garbage collection result.
+ *
+ * @property deletedObjects - Number of unreferenced objects deleted
+ * @property deletedPartials - Number of incomplete uploads deleted
+ * @property retainedObjects - Number of objects still referenced
+ * @property skippedYoung - Number of objects skipped due to minAge
+ * @property bytesFreed - Total bytes freed by deletion
+ */
+export declare const GcResultType: StructType<{
+    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).
+ *
+ * @property name - Package name
+ * @property version - Semantic version string
+ */
+export declare const PackageListItemType: StructType<{
+    readonly name: StringType;
+    readonly version: StringType;
+}>;
+/**
+ * Basic package info.
+ *
+ * @property name - Package name
+ * @property version - Semantic version string
+ * @property hash - SHA256 content hash
+ */
+export declare const PackageInfoType: StructType<{
+    readonly name: StringType;
+    readonly version: StringType;
+    readonly hash: StringType;
+}>;
+/**
+ * Detailed package information including structure.
+ *
+ * @property name - Package name
+ * @property version - Semantic version string
+ * @property hash - SHA256 content hash
+ * @property tasks - List of task names defined in the package
+ * @property dataStructure - East structure type describing the package's data schema
+ */
+export declare const PackageDetailsType: StructType<{
+    readonly name: StringType;
+    readonly version: StringType;
+    readonly hash: StringType;
+    readonly tasks: ArrayType<StringType>;
+    readonly dataStructure: import("@elaraai/east").RecursiveType<VariantType<{
+        readonly value: StructType<{
+            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 writable: BooleanType;
+        }>;
+        readonly struct: import("@elaraai/east").DictType<StringType, import("@elaraai/east").RecursiveTypeMarker>;
+    }>>;
+}>;
+/**
+ * Request to create a new workspace.
+ *
+ * @property name - Unique workspace name
+ */
+export declare const WorkspaceCreateRequestType: StructType<{
+    readonly name: StringType;
+}>;
+/**
+ * Workspace summary information.
+ *
+ * @property name - Workspace name
+ * @property deployed - Whether a package is deployed to this workspace
+ * @property packageName - Name of deployed package (if deployed)
+ * @property packageVersion - Version of deployed package (if deployed)
+ */
+export declare const WorkspaceInfoType: StructType<{
+    readonly name: StringType;
+    readonly deployed: BooleanType;
+    readonly packageName: OptionType<StringType>;
+    readonly packageVersion: OptionType<StringType>;
+}>;
+/**
+ * Request to deploy a package to a workspace.
+ *
+ * @property packageRef - Package reference in format "name" or "name@version"
+ */
+export declare const WorkspaceDeployRequestType: StructType<{
+    readonly packageRef: StringType;
+}>;
+/**
+ * Workspace export request body.
+ *
+ * @property name - Optional custom package name
+ * @property version - Optional custom version
+ */
+export declare const WorkspaceExportRequestType: StructType<{
+    readonly name: OptionType<StringType>;
+    readonly version: OptionType<StringType>;
+}>;
+/**
+ * Dataset status variant.
+ *
+ * - `unset`: No value assigned to this dataset
+ * - `stale`: Value exists but is outdated (upstream changed)
+ * - `up-to-date`: Value is current
+ */
+export declare const DatasetStatusType: VariantType<{
+    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<{
+    readonly cached: BooleanType;
+}>;
+/** Task waiting on dependencies. @property reason - Human-readable wait reason */
+export declare const TaskStatusWaitingType: StructType<{
+    readonly reason: StringType;
+}>;
+/** Task currently executing. */
+export declare const TaskStatusInProgressType: StructType<{
+    /** Process ID of the running task */
+    readonly pid: OptionType<IntegerType>;
+    /** ISO timestamp when execution started */
+    readonly startedAt: OptionType<StringType>;
+}>;
+/** Task exited with non-zero code. */
+export declare const TaskStatusFailedType: StructType<{
+    /** Process exit code */
+    readonly exitCode: IntegerType;
+    /** ISO timestamp when task completed */
+    readonly completedAt: OptionType<StringType>;
+}>;
+/** Task encountered an internal error. */
+export declare const TaskStatusErrorType: StructType<{
+    /** Error message */
+    readonly message: StringType;
+    /** ISO timestamp when error occurred */
+    readonly completedAt: OptionType<StringType>;
+}>;
+/** Task was running but process is no longer alive. */
+export declare const TaskStatusStaleRunningType: StructType<{
+    /** Last known process ID */
+    readonly pid: OptionType<IntegerType>;
+    /** ISO timestamp when execution started */
+    readonly startedAt: OptionType<StringType>;
+}>;
+/**
+ * Task execution status variant.
+ *
+ * - `up-to-date`: Task completed successfully (cached indicates if from cache)
+ * - `ready`: Task is ready to run (all inputs available)
+ * - `waiting`: Task waiting on upstream dependencies
+ * - `in-progress`: Task currently executing
+ * - `failed`: Task exited with non-zero exit code
+ * - `error`: Internal error during task execution
+ * - `stale-running`: Task was marked running but process died
+ */
+export declare const TaskStatusType: VariantType<{
+    readonly 'up-to-date': StructType<{
+        readonly cached: BooleanType;
+    }>;
+    readonly ready: NullType;
+    readonly waiting: StructType<{
+        readonly reason: StringType;
+    }>;
+    readonly 'in-progress': StructType<{
+        /** Process ID of the running task */
+        readonly pid: OptionType<IntegerType>;
+        /** ISO timestamp when execution started */
+        readonly startedAt: OptionType<StringType>;
+    }>;
+    readonly failed: StructType<{
+        /** Process exit code */
+        readonly exitCode: IntegerType;
+        /** ISO timestamp when task completed */
+        readonly completedAt: OptionType<StringType>;
+    }>;
+    readonly error: StructType<{
+        /** Error message */
+        readonly message: StringType;
+        /** ISO timestamp when error occurred */
+        readonly completedAt: OptionType<StringType>;
+    }>;
+    readonly 'stale-running': StructType<{
+        /** Last known process ID */
+        readonly pid: OptionType<IntegerType>;
+        /** ISO timestamp when execution started */
+        readonly startedAt: OptionType<StringType>;
+    }>;
+}>;
+/**
+ * Status information for a single dataset.
+ *
+ * @property path - Dataset path (e.g., ".inputs.config" or ".tasks.foo.output")
+ * @property status - Current status (unset, stale, or up-to-date)
+ * @property hash - SHA256 hash of current value (if set)
+ * @property isTaskOutput - True if this dataset is produced by a task
+ * @property producedBy - Name of task that produces this dataset (if isTaskOutput)
+ */
+export declare const DatasetStatusInfoType: StructType<{
+    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.
+ *
+ * @property name - Task name
+ * @property hash - Task definition hash (changes when task code changes)
+ * @property status - Current execution status
+ * @property inputs - Dataset paths this task reads from
+ * @property output - Dataset path this task writes to
+ * @property dependsOn - Names of tasks that must complete before this one
+ */
+export declare const TaskStatusInfoType: StructType<{
+    readonly name: StringType;
+    readonly hash: StringType;
+    readonly status: VariantType<{
+        readonly 'up-to-date': StructType<{
+            readonly cached: BooleanType;
+        }>;
+        readonly ready: NullType;
+        readonly waiting: StructType<{
+            readonly reason: StringType;
+        }>;
+        readonly 'in-progress': StructType<{
+            /** Process ID of the running task */
+            readonly pid: OptionType<IntegerType>;
+            /** ISO timestamp when execution started */
+            readonly startedAt: OptionType<StringType>;
+        }>;
+        readonly failed: StructType<{
+            /** Process exit code */
+            readonly exitCode: IntegerType;
+            /** ISO timestamp when task completed */
+            readonly completedAt: OptionType<StringType>;
+        }>;
+        readonly error: StructType<{
+            /** Error message */
+            readonly message: StringType;
+            /** ISO timestamp when error occurred */
+            readonly completedAt: OptionType<StringType>;
+        }>;
+        readonly 'stale-running': StructType<{
+            /** Last known process ID */
+            readonly pid: OptionType<IntegerType>;
+            /** ISO timestamp when execution started */
+            readonly startedAt: OptionType<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 */
+    readonly datasets: StructType<{
+        readonly total: IntegerType;
+        readonly unset: IntegerType;
+        readonly stale: IntegerType;
+        readonly upToDate: IntegerType;
+    }>;
+    /** Task status counts */
+    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;
+    }>;
+}>;
+/**
+ * Complete workspace status including all datasets, tasks, and summary.
+ *
+ * @property workspace - Workspace name
+ * @property lock - Information about current lock holder (if locked)
+ * @property datasets - Status of all datasets in the workspace
+ * @property tasks - Status of all tasks in the workspace
+ * @property summary - Aggregated counts by status
+ */
+export declare const WorkspaceStatusResultType: StructType<{
+    readonly workspace: StringType;
+    readonly lock: OptionType<StructType<{
+        readonly pid: IntegerType;
+        readonly acquiredAt: StringType;
+        readonly bootId: OptionType<StringType>;
+        readonly command: 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>;
+    }>>;
+    readonly tasks: ArrayType<StructType<{
+        readonly name: StringType;
+        readonly hash: StringType;
+        readonly status: VariantType<{
+            readonly 'up-to-date': StructType<{
+                readonly cached: BooleanType;
+            }>;
+            readonly ready: NullType;
+            readonly waiting: StructType<{
+                readonly reason: StringType;
+            }>;
+            readonly 'in-progress': StructType<{
+                /** Process ID of the running task */
+                readonly pid: OptionType<IntegerType>;
+                /** ISO timestamp when execution started */
+                readonly startedAt: OptionType<StringType>;
+            }>;
+            readonly failed: StructType<{
+                /** Process exit code */
+                readonly exitCode: IntegerType;
+                /** ISO timestamp when task completed */
+                readonly completedAt: OptionType<StringType>;
+            }>;
+            readonly error: StructType<{
+                /** Error message */
+                readonly message: StringType;
+                /** ISO timestamp when error occurred */
+                readonly completedAt: OptionType<StringType>;
+            }>;
+            readonly 'stale-running': StructType<{
+                /** Last known process ID */
+                readonly pid: OptionType<IntegerType>;
+                /** ISO timestamp when execution started */
+                readonly startedAt: OptionType<StringType>;
+            }>;
+        }>;
+        readonly inputs: ArrayType<StringType>;
+        readonly output: StringType;
+        readonly dependsOn: ArrayType<StringType>;
+    }>>;
+    readonly summary: StructType<{
+        /** Dataset status counts */
+        readonly datasets: StructType<{
+            readonly total: IntegerType;
+            readonly unset: IntegerType;
+            readonly stale: IntegerType;
+            readonly upToDate: IntegerType;
+        }>;
+        /** Task status counts */
+        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;
+        }>;
+    }>;
+}>;
+/**
+ * Task list item (summary info).
+ *
+ * @property name - Task name
+ * @property hash - Task definition hash
+ */
+export declare const TaskListItemType: StructType<{
+    readonly name: StringType;
+    readonly hash: StringType;
+}>;
+/**
+ * Detailed task information.
+ *
+ * @property name - Task name
+ * @property hash - Task definition hash
+ * @property commandIr - East IR for the task's command
+ * @property inputs - Tree paths for task inputs
+ * @property output - Tree path for task output
+ */
+export declare const TaskDetailsType: StructType<{
+    readonly name: StringType;
+    readonly hash: StringType;
+    readonly commandIr: StringType;
+    readonly inputs: ArrayType<ArrayType<VariantType<{
+        readonly field: StringType;
+    }>>>;
+    readonly output: ArrayType<VariantType<{
+        readonly field: StringType;
+    }>>;
+}>;
+/**
+ * Request to start dataflow execution.
+ *
+ * @property concurrency - Maximum parallel tasks (default: 4)
+ * @property force - Force re-execution of all tasks
+ * @property filter - Filter to specific task names (glob pattern)
+ */
+export declare const DataflowRequestType: StructType<{
+    readonly concurrency: OptionType<IntegerType>;
+    readonly force: BooleanType;
+    readonly filter: OptionType<StringType>;
+}>;
+/**
+ * Chunk of log data from task execution.
+ *
+ * @property data - Log content (UTF-8 text)
+ * @property offset - Byte offset from start of log
+ * @property size - Size of this chunk in bytes
+ * @property totalSize - Total size of the log file
+ * @property complete - True if this chunk reaches end of file
+ */
+export declare const LogChunkType: StructType<{
+    readonly data: StringType;
+    readonly offset: IntegerType;
+    readonly size: IntegerType;
+    readonly totalSize: IntegerType;
+    readonly complete: BooleanType;
+}>;
+/**
+ * Result of executing a single task.
+ *
+ * @property name - Task name
+ * @property cached - True if result was retrieved from cache
+ * @property state - Execution outcome (success, failed, error, skipped)
+ * @property duration - Execution time in seconds
+ */
+export declare const TaskExecutionResultType: StructType<{
+    readonly name: StringType;
+    readonly cached: BooleanType;
+    readonly state: VariantType<{
+        readonly success: NullType;
+        readonly failed: StructType<{
+            readonly exitCode: IntegerType;
+        }>;
+        readonly error: StructType<{
+            readonly message: StringType;
+        }>;
+        readonly skipped: NullType;
+    }>;
+    readonly duration: FloatType;
+}>;
+/**
+ * Result of dataflow execution.
+ *
+ * @property success - True if all tasks completed successfully
+ * @property executed - Number of tasks that were executed
+ * @property cached - Number of tasks that used cached results
+ * @property failed - Number of tasks that failed
+ * @property skipped - Number of tasks that were skipped
+ * @property tasks - Per-task execution results
+ * @property duration - Total execution time in seconds
+ */
+export declare const DataflowResultType: StructType<{
+    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;
+            }>;
+            readonly error: StructType<{
+                readonly message: StringType;
+            }>;
+            readonly skipped: NullType;
+        }>;
+        readonly duration: FloatType;
+    }>>;
+    readonly duration: FloatType;
+}>;
+/**
+ * Dataflow event types for API polling.
+ *
+ * - `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 for API polling responses.
+ *
+ * - `running`: Execution is in progress
+ * - `completed`: Execution finished successfully
+ * - `failed`: Execution finished with failures
+ * - `aborted`: Execution was cancelled
+ *
+ * Note: Named "Api*" to distinguish from the on-disk ExecutionStatusType
+ * in execution.ts which tracks individual task execution states.
+ */
+export declare const ApiExecutionStatusType: 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;
+}>;
+/**
+ * Dataflow execution state returned by API polling.
+ *
+ * A lightweight view of the execution state for client polling.
+ *
+ * Note: Named "Api*" to distinguish from the persistent
+ * DataflowExecutionStateType in dataflow.ts which stores the full
+ * execution state on disk.
+ *
+ * @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 ApiDataflowExecutionStateType: 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>;
+}>;
+/**
+ * Tree branch kind variant.
+ *
+ * Currently only `struct` branches exist. Future: `dict`, `array`, `variant`.
+ */
+export declare const TreeKindType: VariantType<{
+    readonly struct: NullType;
+}>;
+/**
+ * A list entry -- either a dataset leaf or a tree branch.
+ *
+ * Used by the `?list=true&status=true` endpoints to return both
+ * tree structure entries and dataset leaves in a single flat list.
+ */
+export declare const ListEntryType: VariantType<{
+    readonly dataset: 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>;
+    }>;
+    readonly tree: StructType<{
+        readonly path: StringType;
+        readonly kind: VariantType<{
+            readonly struct: NullType;
+        }>;
+    }>;
+}>;
+/**
+ * Detailed status of a single dataset.
+ *
+ * @property path - Dataset path (e.g., ".inputs.config")
+ * @property type - East type of the dataset
+ * @property refType - Ref type: "unassigned", "null", or "value"
+ * @property hash - Object hash (None if unassigned/null)
+ * @property size - Size in bytes (None if unassigned)
+ */
+export declare const DatasetStatusDetailType: 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 refType: StringType;
+    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 PackageInfo = ValueTypeOf<typeof PackageInfoType>;
+export type PackageDetails = ValueTypeOf<typeof PackageDetailsType>;
+export type WorkspaceInfo = ValueTypeOf<typeof WorkspaceInfoType>;
+export type WorkspaceCreateRequest = ValueTypeOf<typeof WorkspaceCreateRequestType>;
+export type WorkspaceDeployRequest = ValueTypeOf<typeof WorkspaceDeployRequestType>;
+export type DatasetStatus = ValueTypeOf<typeof DatasetStatusType>;
+export type TaskStatus = ValueTypeOf<typeof TaskStatusType>;
+export type DatasetStatusInfo = ValueTypeOf<typeof DatasetStatusInfoType>;
+export type TaskStatusInfo = ValueTypeOf<typeof TaskStatusInfoType>;
+export type WorkspaceStatusSummary = ValueTypeOf<typeof WorkspaceStatusSummaryType>;
+export type WorkspaceStatusResult = ValueTypeOf<typeof WorkspaceStatusResultType>;
+export type TaskListItem = ValueTypeOf<typeof TaskListItemType>;
+export type TaskDetails = ValueTypeOf<typeof TaskDetailsType>;
+export type DataflowRequest = ValueTypeOf<typeof DataflowRequestType>;
+export type LogChunk = ValueTypeOf<typeof LogChunkType>;
+export type TaskExecutionResult = ValueTypeOf<typeof TaskExecutionResultType>;
+export type DataflowResult = ValueTypeOf<typeof DataflowResultType>;
+export type DataflowEvent = ValueTypeOf<typeof DataflowEventType>;
+export type ApiExecutionStatus = ValueTypeOf<typeof ApiExecutionStatusType>;
+export type DataflowExecutionSummary = ValueTypeOf<typeof DataflowExecutionSummaryType>;
+export type ApiDataflowExecutionState = ValueTypeOf<typeof ApiDataflowExecutionStateType>;
+export type ExecutionHistoryStatus = ValueTypeOf<typeof ExecutionHistoryStatusType>;
+export type ExecutionListItem = ValueTypeOf<typeof ExecutionListItemType>;
+export type TreeKind = ValueTypeOf<typeof TreeKindType>;
+export type ListEntry = ValueTypeOf<typeof ListEntryType>;
+export type DatasetStatusDetail = ValueTypeOf<typeof DatasetStatusDetailType>;
+//# sourceMappingURL=api.d.ts.map